Виявлення неправильного використання delete [] проти видалення під час компіляції

Я хотів би знати, чи можна виявити deleteпомилку, прокоментовану нижче, під час компіляції? Особливо, я хотів би почути про компілятор g ++.

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

Взагалі компілятор не може виявити подібні помилки. Приклад: Припустимо, конструктор для деякого класу виділяє деякий член даних, використовуючи new TypeName[], але деструктор помилково використовує deleteзамість delete[]. Якщо конструктор і деструктор визначені в окремих блоках компіляції, як компілятор повинен знати при компілюванні файлу, який визначає деструктор, що використання не відповідає використанню в окремо складеному файлі, що визначає конструктор?

Що стосується компіляторів GNU, то це не так. Як зазначалося вище, це не може зробити в загальному випадку. Компілятору не потрібно виявляти такі невідповідні нові помилки / нові видалення, оскільки це невизначена поведінка. UB - картка постачальника компілятора, "вийти з в'язниці".

Такі інструменти, як valgrind, можуть і виявляти подібні нові / видалення невідповідностей, але робити це під час виконання. Можливо, є інструмент статичного аналізу, який розглядає всі вихідні файли, які в кінцевому підсумку будуть скомпільовані для формування виконуваного файлу, але я не маю жодного такого інструмента статичного аналізу, який би виявляв подібні помилки.

Ви можете використовувати відповідні класи RAII для delete. Це єдиний безпечний спосіб зробити це, і ця помилка є лише однією з дуже, дуже багатьох, з якими ви зіткнетесь, називаючи deleteсебе.

Завжди використовуйте класи для управління динамічними ресурсами протягом усього життя, і система типів забезпечить правильне знищення ресурсів.

Редагувати: "Що робити, якщо ви перевіряєте код і не можете його змінити?" Ви трахнули.

Ця конкретна помилка - так. Такого роду помилка взагалі: на жаль, ні! Це передбачало б передбачити потік виконання без його фактичного виконання, а це неможливо для довільних програм. (Ось чому більшість компіляторів навіть не намагаються виявити такі прості випадки, як ваш приклад.)

Тому відповідь DeadMG відповідна: не намагайтеся виправити це правильно, звертаючи увагу - людська увага помилкова. Використовуйте мовні засоби та нехай комп'ютер зверне увагу.

Тривіальний випадок, який ви показуєте, може бути виявлений під час компіляції, оскільки інстанція та знищення об'єкта знаходяться в однаковій мірі. Загалом, видалення не в тому ж обсязі або навіть у тому самому вихідному файлі, що і інстанція. А тип вказівника C ++ не несе інформації про те, чи посилається він на один об'єкт свого типу або масив, не кажучи вже про схему розподілу. Тож неможливо діагностувати це взагалі під час компіляції.

Чому б не діагностувати спеціальні випадки, які можливі?

У C ++ вже є інструменти для боротьби з витоком динамічних ресурсів, прив’язаних до областей, а саме розумні покажчики та масиви вищого рівня ( std::vector).

Навіть якщо ви використовуєте правильний deleteаромат, ваш код все ще не є винятком безпечним. Якщо код між new[]і delete[]закінчується динамічним виходом, видалення ніколи не виконується.

Що стосується виявлення часу виконання, Valgrindінструмент робить гарну роботу з виявлення цього під час виконання. Дивитися:

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

Звичайно, Valgrind працює не на всіх платформах, і не завжди практично або можливо відтворити всі ситуації під час роботи інструменту.

Деякі тривіальні приклади виявлення за часом компіляції / статичного аналізу:

На хості RHEL7 с 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

З clang++ 3.7.1RHEL7

> 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.

Статичний аналізатор Кланг також може виявити, коли std::unique_ptrйого не пройти<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.

Оновіть нижче посилання на роботу, яка додала це до кланг, тестів та однієї помилки, яку я знайшов.

Це було додано до clang з reviews.llvm.org/D4661 - "Виявити невідповідність" нового "та" видалити "використання" .

Тести проводяться в тесті / Аналіз / НевідповідністьDeallocator-checker-test.mm

Я знайшов цю відкриту помилку - bugs.llvm.org/show_bug.cgi?id=24819