Утечка памяти, обнаруженная valgrind, но не может найти строку, где я забыл освободить

Question

Вот упрощенная версия кода, я удалил все, что не касается проблемы.

#include <iostream> 
#define N 3 

int main() { 

    int *input; 
    int **cl; 

    input = new int[N]; 
    cl = new int*[N]; 
    for(int i = 0; i < N; i++) { 
     cl[i] = new int[N]; 
    } 


    for(int i = 0; i < N; i++) { 
     delete[] cl[i]; 
    } 
    delete[] cl; 
    delete[] input; 

    return 0; 
} 

И выход Valgrind:

==5782== HEAP SUMMARY: 
==5782==  in use at exit: 72,704 bytes in 1 blocks 
==5782== total heap usage: 6 allocs, 5 frees, 72,776 bytes allocated 
==5782== 
==5782== 72,704 bytes in 1 blocks are still reachable in loss record 1 of 1 
==5782== at 0x4C2DB8F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) 
==5782== by 0x4EC3EFF: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21) 
==5782== by 0x40104E9: call_init.part.0 (dl-init.c:72) 
==5782== by 0x40105FA: call_init (dl-init.c:30) 
==5782== by 0x40105FA: _dl_init (dl-init.c:120) 
==5782== by 0x4000CF9: ??? (in /lib/x86_64-linux-gnu/ld-2.23.so) 
==5782== 
==5782== LEAK SUMMARY: 
==5782== definitely lost: 0 bytes in 0 blocks 
==5782== indirectly lost: 0 bytes in 0 blocks 
==5782==  possibly lost: 0 bytes in 0 blocks 
==5782== still reachable: 72,704 bytes in 1 blocks 
==5782==   suppressed: 0 bytes in 0 blocks 
==5782== 
==5782== For counts of detected and suppressed errors, rerun with: -v 
==5782== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) 

Я только начал изучать C++, может быть, есть некоторые глупые ошибки, что я не могу видеть.

Я знаю, что я также должен проверить, если при распределении не было ошибки «из памяти», но я игнорирую его, чтобы код был более понятным. Я также знаю, что могу использовать, например. вектор и не заботятся о распределении, но я все еще обеспокоен тем, что я делаю неправильно.

Answer 1

На C++ представлены инструменты, которые инкапсулируют управление памятью для вас.

#include <iostream> 
#include <vector> 

int main() { 
    // read the size for the vectors 
    int n; 
    std::cin >> n >> '\n'; 

    // allocate vector with n elements 
    auto input = std::vector<int>{n}; 

    // read the elements 
    for(int i = 0; i < n; i++) { 
     std::cin >> std::setw(1) >> input[i]; 
    } 
    // print them 
    for(const auto& d : input) { 
     std::cout << d << std::endl; 
    } 

    // allocate the vectors and store 1 in each field. 
    auto Cl = std::vector<std::vector<int>>{n, std::vector<int>{n, 1}}; 
    auto Cr = std::vector<std::vector<int>>{n, std::vector<int>{n, 1}}; 

    return 0; 

    // will safely release all the memory here. 
} 

Это выглядит гораздо больше, как C++, и меньше, как C. Векторы будет автоматически обрабатывать все управление памятью для вас.

Остерегайтесь: я не тестировал этот код, поэтому он, вероятно, будет содержать некоторые ошибки. Я предполагаю синтаксис C++ 11, но также легко изменить код на более старый синтаксис C++.

Answer 2

Теперь, когда вы добавили выходной VALGRIND это явно тот же вопрос, как тот, который имеет здесь ответ: Valgrind: Memory still reachable with trivial program using <iostream>

Короткий рассказ в том, что это не ваш код, который вызывает этот доклад. Вы можете удалить все из main() и просто вернуться, и valgrind все равно даст вам эту утечку.

Прочтите принятый ответ на этот вопрос для объяснения.