Mendeteksi kesalahan penggunaan delete [] vs. delete pada waktu kompilasi

Saya ingin tahu apakah mungkin mendeteksi deletekesalahan yang dikomentari di bawah ini pada waktu kompilasi? Terutama, saya ingin mendengar tentang kompiler g ++.

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

Secara umum, kompiler tidak dapat mendeteksi kesalahan seperti itu. Contoh: Misalkan konstruktor untuk beberapa kelas mengalokasikan beberapa anggota data menggunakan new TypeName[], tetapi destruktor salah menggunakan deletesebagai gantinya delete[]. Jika konstruktor dan destruktor didefinisikan dalam unit kompilasi terpisah, bagaimana kompiler mengetahui ketika mengkompilasi file yang mendefinisikan destruktor bahwa penggunaannya tidak konsisten dengan yang ada di file yang dikompilasi secara terpisah yang mendefinisikan konstruktor?

Berkenaan dengan kompiler GNU, itu tidak. Seperti disebutkan di atas, tidak dapat melakukannya dalam kasus umum. Kompiler tidak harus mendeteksi kesalahan baru / hapus yang tidak cocok karena ini adalah perilaku yang tidak terdefinisi. UB adalah kartu "keluar dari penjara" dari vendor kompiler.

Alat seperti valgrind dapat dan memang mendeteksi ketidakcocokan baru / hapus ini, tetapi melakukannya saat runtime. Mungkin ada alat analisis statis yang melihat semua file sumber yang pada akhirnya akan dikompilasi untuk membentuk executable, tapi saya tidak menemukan alat analisis statis yang mendeteksi kesalahan semacam ini.

Anda dapat menggunakan kelas RAII yang sesuai untuk delete. Ini adalah satu-satunya cara aman untuk melakukannya, dan kesalahan ini hanya salah satu dari sangat, sangat banyak yang Anda temui menyebut deletediri Anda.

Selalu gunakan kelas untuk mengelola sumber daya seumur hidup yang dinamis, dan sistem tipe akan menegakkan penghancuran sumber daya yang benar.

Sunting: "Bagaimana jika Anda mengaudit kode dan tidak dapat mengubahnya?" Anda kacau.

Kesalahan khusus ini - ya. Ini jenis kesalahan umum: sayangnya, tidak ada! Itu akan melibatkan memprediksi aliran eksekusi tanpa benar-benar mengeksekusinya, dan itu tidak mungkin untuk program sewenang-wenang. (Itu sebabnya kebanyakan kompiler bahkan tidak mencoba mendeteksi kasus sederhana seperti contoh Anda.)

Karena itu jawaban DeadMG adalah yang tepat: jangan mencoba untuk memperbaikinya dengan memperhatikan - perhatian manusia bisa keliru. Gunakan sarana yang disediakan bahasa dan biarkan komputer memperhatikan.

Kasus sepele yang Anda tunjukkan dapat dideteksi pada waktu kompilasi, karena instantiasi dan penghancuran objek berada dalam cakupan yang sama. Secara umum, penghapusan tidak ada dalam cakupan yang sama, atau bahkan file sumber yang sama, seperti instantiasi. Dan tipe C ++ pointer tidak membawa informasi tentang apakah referensi objek tunggal dari jenis atau array, apalagi skema alokasi. Jadi tidak mungkin untuk mendiagnosis ini pada waktu kompilasi secara umum.

Mengapa tidak mendiagnosis kasus khusus yang mungkin terjadi?

Di C ++ sudah ada alat untuk menangani kebocoran sumber daya dinamis yang terkait dengan cakupan, yaitu smart pointer dan array level yang lebih tinggi ( std::vector).

Bahkan jika Anda menggunakan deleterasa yang benar , kode Anda masih tidak terkecuali aman. Jika kode antara new[]dan delete[]diakhiri dengan keluar dinamis, penghapusan tidak pernah dijalankan.

Sejauh deteksi run-time berjalan, Valgrindalat melakukan pekerjaan yang baik untuk mendeteksi ini pada saat run-time. Menonton:

==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)

Tentu saja, Valgrind tidak berjalan pada semua platform, dan tidak selalu praktis atau mungkin untuk mereproduksi semua situasi run-time di bawah alat ini.

Beberapa contoh deteksi yang sepele pada waktu kompilasi / analisis-statis:

Pada host RHEL7 dengan 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

Dengan clang++ 3.7.1di 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.

The Clang Static Analyzer juga dapat mendeteksi kapan std::unique_ptrtidak lulus<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.

Perbarui di bawah ini dengan tautan ke pekerjaan yang menambahkan ini ke dentang, tes dan satu bug yang saya temukan.

Ini ditambahkan ke dentang dengan reviews.llvm.org/D4661 - "Deteksi ketidakcocokan penggunaan 'baru' dan 'hapus'" .

Tes dalam tes / Analisis / MismatchedDeallocator-checker-test.mm

Saya menemukan bug terbuka ini - bugs.llvm.org/show_bug.cgi?id=24819