Em C++, a palavra-chave delete é usada em duas situações diferentes, dependendo do contexto:

1. Operador delete pode ser usado para liberar memória alocada dinamicamente:

Quando você aloca memória dinamicamente usando new, é necessário liberar essa memória quando não precisar mais dela para evitar vazamentos de memória. O operador delete é usado para liberar a memória alocada dinamicamente. Em contrapartida e para uso automático pode ser(e deve sempre que puder) usar ponteiros inteligentes(smart pointers).

2. Operador delete para funções:

Quando você declara uma função usando delete, está declarando que essa função é excluída e não pode ser usada. Isso é útil para classes com funções-membro que você deseja impedir que sejam chamados ou herdados.

Exemplo de como deletar funções em C++

Suponhamos que você possui essa função abaixo: print_num(int) que recebe como parâmetro o tipo primitivo int:

void print_num(int num){
  std::cout << num << '\n';
}

Ao chamar essa função, note que podemos passar os tipos: char, bool e float/double que ela receberá normalmente:

void print_num(int num){
  std::cout << num << '\n';
}

int main(){
  print_num(9);
  print_num('a');
  print_num(true);
  print_num(3.6);
}

Ao compilar note que funcionará normalmente:

g++ main.cpp
./a.out
9
97
1
3

Para evitar essa sobrecarga usamos a declaração delete para anular alguns tipos:

void print_num(char) = delete;

Nesse caso o tipo char e float/double já receberão erro ao compilar:

void print_num(char) = delete; ■ Call to deleted function 'print_num'

Lembrando que o float/double já receberão um warning(se você estiver usando um LSP), mas compilará normalmente!

Ainda podemos usar também para o tipo bool também não sobrecarregar:

void print_num(bool) = delete;

Sendo assim, para conseguirmos compilar nosso código precisaremos comentar as linhas referentes ao código acima, deixando assim ao final:

#include <iostream>

void print_num(int num){
  std::cout << num << '\n';
}

void print_num(char) = delete;
void print_num(bool) = delete;

int main(){
  print_num(9);
  //print_num('a'); ■ Call to deleted function 'print_num'
  //print_num(true); ■ Call to deleted function 'print_num'
  //print_num(3.6); ■ Call to 'print_num' is ambiguous
  return 0;
}

Lembrando que você ainda pode optimizar seu código usando template, ficando like a boss!:

#include <iostream>

void print_num(int num){
  std::cout << num << '\n';
}

template<typename T>
void print_num(T) = delete;

int main(){
  print_num(9);
  //print_num('a'); ■ Call to deleted function 'print_num'
  //print_num(true); ■ Call to deleted function 'print_num'
  //print_num(3.6); ■ Call to 'print_num' is ambiguous
  return 0;
}

Em resumo, dentro desse contexto a palavra-chave delete em C++ para ‘deletar’ funções quer dizer:

delete = “eu proíbo isso” ou “isso não existe”

Para mais informações acesse aqui.

cpp

Marcos Oliveira

Desenvolvedor de software

https://github.com/terroo