Detectando uso indevido de delete [] vs. delete em tempo de compilação

Gostaria de saber se é possível detectar o deleteerro comentado abaixo em tempo de compilação? Especialmente, eu gostaria de ouvir sobre o compilador g ++.

ClassTypeA *abc_ptr = new ClassTypeA[100];  
abc_ptr[10].data_ = 1;  
delete abc_ptr; // error, should be delete []  

Em geral, o compilador não pode detectar esses erros. Exemplo: suponha que o construtor de alguma classe aloque algum membro de dados usando new TypeName[], mas o destruidor usa erroneamente em deletevez de delete[]. Se o construtor e o destruidor são definidos em unidades de compilação separadas, como o compilador deve saber ao compilar o arquivo que define o destruidor que o uso é inconsistente com o do arquivo compilado separadamente que define o construtor?

Com relação aos compiladores GNU, isso não acontece. Como observado acima, não pode ser feito no caso geral. Um compilador não precisa detectar erros de exclusão / exclusão diferentes porque esse é um comportamento indefinido. UB é o cartão "saia da cadeia" do fornecedor do compilador.

Ferramentas como o valgrind podem detectar esses tipos de incompatibilidades novas / excluídas, mas o fazem em tempo de execução. Pode haver uma ferramenta de análise estática que analisa todos os arquivos de origem que eventualmente serão compilados para formar um executável, mas eu não utilizo nenhuma ferramenta de análise estática que detecta esse tipo de erro.

Você pode usar as classes RAII apropriadas para delete. Esta é a única maneira segura de fazê-lo, e esse erro é apenas um dos muitos que você encontrará chamando a deletesi mesmo.

Sempre use classes para gerenciar recursos dinâmicos da vida útil, e o sistema de tipos aplicará a destruição correta dos recursos.

Edit: "E se você estiver auditando o código e não puder alterá-lo?" Você está fodido.

Este erro em particular - sim. Esse tipo de erro geralmente: infelizmente não! Isso envolveria prever o fluxo de execução sem realmente executá-lo, e isso não é possível para programas arbitrários. (É por isso que a maioria dos compiladores nem tenta detectar casos simples como o seu exemplo.)

Portanto, a resposta do DeadMG é a apropriada: não tente acertar prestando atenção - a atenção humana é falível. Use os meios fornecidos pelo idioma e deixe o computador prestar atenção.

O caso trivial que você mostra pode ser detectado em tempo de compilação, porque a instanciação e a destruição do objeto estão no mesmo escopo. Em geral, a exclusão não está no mesmo escopo ou no mesmo arquivo de origem que a instanciação. E o tipo de um ponteiro C ++ não carrega informações sobre se ele faz referência a um único objeto de seu tipo ou matriz, sem falar no esquema de alocação. Portanto, não é possível diagnosticar isso em tempo de compilação em geral.

Por que não diagnosticar os casos especiais possíveis?

No C ++, já existem ferramentas para lidar com o vazamento de recursos dinâmicos vinculados a escopos, como ponteiros inteligentes e matrizes de nível superior ( std::vector).

Mesmo se você usar o deletesabor correto , seu código ainda não será seguro. Se o código entre new[]e delete[]termina com uma saída dinâmica, a exclusão nunca é executada.

No que diz respeito à detecção em tempo de execução, a Valgrindferramenta faz um bom trabalho ao detectar isso em tempo de execução. Ver:

==26781== Command: ./a.out
==26781==
==26781== Mismatched free() / delete / delete []
==26781==    at 0x402ACFC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==26781==    by 0x8048498: main (in /home/kaz/test/a.out)
==26781==  Address 0x4324028 is 0 bytes inside a block of size 80 alloc'd
==26781==    at 0x402B454: operator new[](unsigned int) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==26781==    by 0x8048488: main (in /home/kaz/test/a.out)

Obviamente, o Valgrind não é executado em todas as plataformas, e nem sempre é prático ou possível reproduzir todas as situações de tempo de execução na ferramenta.

Alguns exemplos triviais de detecção em tempo de compilação / tempo de análise estática:

Em um host RHEL7 com cppcheck 1.77 and 1.49

> cat test.cc
#include <memory>
int main(){char* buf = new char[10];delete buf;}

http://cppcheck.sourceforge.net/

> cppcheck -x c++ test.cc
Checking test.cc ...
[test.cc:2]: (error) Mismatching allocation and deallocation: buf

Com clang++ 3.7.1no RHEL7

> clang++ --analyze -x c++ test.cc
test.cc:2:37: warning: Memory allocated by 'new[]' should be deallocated by
'delete[]', not 'delete'
int main(){char* buf = new char[10];delete buf;}
                                    ^~~~~~~~~~
1 warning generated.

O Clang Static Analyzer também pode detectar quando std::unique_ptrnão é passado<char[]>

> cat test2.cc
#include <memory>
int main(){std::unique_ptr<char> buf(new char[10]);}

https://clang-analyzer.llvm.org/

> clang++ --analyze -x c++ -std=c++11 test2.cc
In file included from test2.cc:1:
In file included from /opt/rh/devtoolset-4/root/usr/lib/gcc/x86_64-redhat-linux/5.3.1/
../../../../include/c++/5.3.1/memory:81:
/opt/rh/devtoolset-4/root/usr/lib/gcc/x86_64-redhat-linux/5.3.1/
../../../../include/c++/5.3.1/bits/unique_ptr.h:76:2: 
warning: Memory allocated by
      'new[]' should be deallocated by 'delete[]', not 'delete'
        delete __ptr;
        ^~~~~~~~~~~~
1 warning generated.

Atualize abaixo com um link para o trabalho que adicionou isso ao clang, aos testes e a um bug que encontrei.

Isso foi adicionado ao clang com reviews.llvm.org/D4661 - "Detectar incompatibilidades 'novas' e 'excluir' usos" .

Os testes estão em test / Analysis / MismatchedDeallocator-checker-test.mm

Encontrei este bug aberto - bugs.llvm.org/show_bug.cgi?id=24819