Matrix template, memory leak - c++

Question

I code a simple program to apply a complex function (z,exp(z),...) to a pgm image and return the result. The program is working and does what it should do. However, there are 11 memory leaks that I'm not been able to work out. My guess is that the trouble is in the matrix template container I code and its constructors and destructor.
To debug I'm using valgrind and the program has been written in c++.
The result of running valgrind is the following:
==7690== Memcheck, a memory error detector
==7690== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==7690== Using Valgrind-3.10.0 and LibVEX; rerun with -h for copyright info
==7690== Command: ./tp0 -i f14.pgm -f z -o ff14.pgm
==7690==
==7690==
==7690== HEAP SUMMARY:
==7690== in use at exit: 160 bytes in 11 blocks
==7690== total heap usage: 45 allocs, 34 frees, 18,357 bytes allocated
==7690==
==7690== 8 bytes in 1 blocks are still reachable in loss record 1 of 11
==7690== at 0x4C298A0: operator new[](unsigned long) (vg_replace_malloc.c:389)
==7690== by 0x404871: Matrix<Pixel>::Matrix(unsigned int, unsigned int) (matrix.hpp:44)
==7690== by 0x404471: PGMImage::PGMImage(unsigned int, unsigned int) (pgm_image.cpp:14)
==7690== by 0x405475: PGMParser::set_pgm_dimensions(std::vector<int, std::allocator<int> >) (pgm_parser.cpp:147)
==7690== by 0x4050CD: PGMParser::get_pgm() (pgm_parser.cpp:94)
==7690== by 0x404D67: PGMParser::PGMParser(std::string const&) (pgm_parser.cpp:25)
==7690== by 0x404212: main (main.cpp:52)
==7690==
==7690== 8 bytes in 1 blocks are still reachable in loss record 2 of 11
==7690== at 0x4C298A0: operator new[](unsigned long) (vg_replace_malloc.c:389)
==7690== by 0x403703: Matrix<Complex>::Matrix(unsigned int, unsigned int) (matrix.hpp:44)
==7690== by 0x4024A5: PGMTransformation::PGMTransformation(PGMImage const&, std::string const&) (PGMTransformation.cpp:49)
==7690== by 0x404240: main (main.cpp:55)
==7690==
==7690== 8 bytes in 1 blocks are still reachable in loss record 3 of 11
==7690== at 0x4C298A0: operator new[](unsigned long) (vg_replace_malloc.c:389)
==7690== by 0x4049C9: Matrix<Pixel>::Matrix(Matrix<Pixel> const&) (matrix.hpp:56)
==7690== by 0x404579: PGMImage::PGMImage(PGMImage const&) (pgm_image.cpp:31)
==7690== by 0x4024DD: PGMTransformation::PGMTransformation(PGMImage const&, std::string const&) (PGMTransformation.cpp:57)
==7690== by 0x404240: main (main.cpp:55)
==7690==
==7690== 12 bytes in 1 blocks are still reachable in loss record 4 of 11
==7690== at 0x4C298A0: operator new[](unsigned long) (vg_replace_malloc.c:389)
==7690== by 0x4048B4: Matrix<Pixel>::Matrix(unsigned int, unsigned int) (matrix.hpp:46)
==7690== by 0x404471: PGMImage::PGMImage(unsigned int, unsigned int) (pgm_image.cpp:14)
==7690== by 0x405475: PGMParser::set_pgm_dimensions(std::vector<int, std::allocator<int> >) (pgm_parser.cpp:147)
==7690== by 0x4050CD: PGMParser::get_pgm() (pgm_parser.cpp:94)
==7690== by 0x404D67: PGMParser::PGMParser(std::string const&) (pgm_parser.cpp:25)
==7690== by 0x404212: main (main.cpp:52)
==7690==
==7690== 12 bytes in 1 blocks are still reachable in loss record 5 of 11
==7690== at 0x4C298A0: operator new[](unsigned long) (vg_replace_malloc.c:389)
==7690== by 0x404A15: Matrix<Pixel>::Matrix(Matrix<Pixel> const&) (matrix.hpp:59)
==7690== by 0x404579: PGMImage::PGMImage(PGMImage const&) (pgm_image.cpp:31)
==7690== by 0x4024DD: PGMTransformation::PGMTransformation(PGMImage const&, std::string const&) (PGMTransformation.cpp:57)
==7690== by 0x404240: main (main.cpp:55)
==7690==
==7690== 16 bytes in 1 blocks are still reachable in loss record 6 of 11
==7690== at 0x4C29180: operator new(unsigned long) (vg_replace_malloc.c:324)
==7690== by 0x40445E: PGMImage::PGMImage(unsigned int, unsigned int) (pgm_image.cpp:14)
==7690== by 0x405475: PGMParser::set_pgm_dimensions(std::vector<int, std::allocator<int> >) (pgm_parser.cpp:147)
==7690== by 0x4050CD: PGMParser::get_pgm() (pgm_parser.cpp:94)
==7690== by 0x404D67: PGMParser::PGMParser(std::string const&) (pgm_parser.cpp:25)
==7690== by 0x404212: main (main.cpp:52)
==7690==
==7690== 16 bytes in 1 blocks are still reachable in loss record 7 of 11
==7690== at 0x4C29180: operator new(unsigned long) (vg_replace_malloc.c:324)
==7690== by 0x40248A: PGMTransformation::PGMTransformation(PGMImage const&, std::string const&) (PGMTransformation.cpp:49)
==7690== by 0x404240: main (main.cpp:55)
==7690==
==7690== 16 bytes in 1 blocks are still reachable in loss record 8 of 11
==7690== at 0x4C298A0: operator new[](unsigned long) (vg_replace_malloc.c:389)
==7690== by 0x403740: Matrix<Complex>::Matrix(unsigned int, unsigned int) (matrix.hpp:46)
==7690== by 0x4024A5: PGMTransformation::PGMTransformation(PGMImage const&, std::string const&) (PGMTransformation.cpp:49)
==7690== by 0x404240: main (main.cpp:55)
==7690==
==7690== 16 bytes in 1 blocks are still reachable in loss record 9 of 11
==7690== at 0x4C29180: operator new(unsigned long) (vg_replace_malloc.c:324)
==7690== by 0x404564: PGMImage::PGMImage(PGMImage const&) (pgm_image.cpp:31)
==7690== by 0x4024DD: PGMTransformation::PGMTransformation(PGMImage const&, std::string const&) (PGMTransformation.cpp:57)
==7690== by 0x404240: main (main.cpp:55)
==7690==
==7690== 24 bytes in 1 blocks are still reachable in loss record 10 of 11
==7690== at 0x4C29180: operator new(unsigned long) (vg_replace_malloc.c:324)
==7690== by 0x405464: PGMParser::set_pgm_dimensions(std::vector<int, std::allocator<int> >) (pgm_parser.cpp:147)
==7690== by 0x4050CD: PGMParser::get_pgm() (pgm_parser.cpp:94)
==7690== by 0x404D67: PGMParser::PGMParser(std::string const&) (pgm_parser.cpp:25)
==7690== by 0x404212: main (main.cpp:52)
==7690==
==7690== 24 bytes in 1 blocks are still reachable in loss record 11 of 11
==7690== at 0x4C29180: operator new(unsigned long) (vg_replace_malloc.c:324)
==7690== by 0x4024CB: PGMTransformation::PGMTransformation(PGMImage const&, std::string const&) (PGMTransformation.cpp:57)
==7690== by 0x404240: main (main.cpp:55)
==7690==
==7690== LEAK SUMMARY:
==7690== definitely lost: 0 bytes in 0 blocks
==7690== indirectly lost: 0 bytes in 0 blocks
==7690== possibly lost: 0 bytes in 0 blocks
==7690== still reachable: 160 bytes in 11 blocks
==7690== suppressed: 0 bytes in 0 blocks
==7690==
==7690== For counts of detected and suppressed errors, rerun with: -v
==7690== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
The part of code I think is crashing of matrix template is the following:
template<typename T>
class Matrix
{
private:
T** matrix_;
unsigned int rows_;
unsigned int cols_;
public:
Matrix();
Matrix(unsigned int, unsigned int);
Matrix(Matrix const &);
~Matrix();
Matrix const &operator=(Matrix const &);
//more methods...
};
template<typename T>
Matrix<T>::Matrix()
: matrix_(0), rows_(0), cols_(0) {}
template<typename T>
Matrix<T>::Matrix(unsigned int rows, unsigned int cols)
{
matrix_ = new T*[rows];
for(unsigned int i=0; i < rows; i++)
matrix_[i] = new T[cols];
rows_ = rows;
cols_ = cols;
}
template<typename T>
Matrix<T>::Matrix(Matrix<T> const & m_orig)
{
rows_ = m_orig.rows_;
cols_ = m_orig.cols_;
matrix_ = new T*[rows_];
for(unsigned int i=0; i < rows_; i++)
{
matrix_[i] = new T[cols_];
for(unsigned int j=0; j < cols_; j++)
matrix_[i][j]=m_orig.matrix_[i][j];
}
}
template<typename T>
Matrix<T>::~Matrix()
{
for(unsigned int i=0; i < rows_; i++)
delete matrix_[i];
delete []matrix_;
rows_ = 0;
cols_ = 0;
}
template<typename T>
Matrix<T> const & Matrix<T>::operator=(Matrix const & m_orig)
{
if(this != &m_orig)
{
for(unsigned int k=0; k < rows_; k++)
delete matrix_[k];
delete matrix_;
rows_ = m_orig.rows_;
cols_ = m_orig.cols_;
matrix_ = new T*[rows_];
for(unsigned int i=0; i < rows_; i++)
{
matrix_[i] = new T[cols_];
for(unsigned int j=0; j < cols_; j++)
matrix_[i][j]=m_orig.matrix_[i][j];
}
}
return *this;
}
There are other classes that could fail, but valgrind tracks almost every leak to the matrix container.
Your help is greatly appreciated!

Answer 1

You should follow the same "pattern" for deallocation with delete as you do for allocation with new,
for(unsigned int i=0; i < rows_; i++)
delete [] matrix_[i];
// ~~ notice []
delete []matrix_;

Answer 2

Your assignment operator is not exception-safe and fails to use the correct version of delete: it releases the memory using delete matrix_ rather than delete[] matrix_. Given the current implementation you are much better off replacing it by this version:
template <typename T>
Matrix<T> const& Matrix<T>::operator= (Matrix<T> orig) {
this->swap(orig);
return *this;
}
template <typename T>
void Matrix<T>::swap(Matrix<T>& other) {
using std::swap;
swap(this->matrix_, other.matrix_);
}
Aside from fixing the memory issues noted above, it also makes the implementation strong exception safe. Of course, doing so assumes that the copy constructor, destructor, and swap() are correctly implemented as they are leveraged to implement this assignment operator:
A copy of the original is made to create the argument (which may be elided: since a copy is made anyway taking the argument by value rather than be const& can reduce the number of copies).
The argument the left hand side are exchanged, making the left hand side the same as the original argument while the argument now contain the original left hand side state ready to be released.
The argument is destroyed, releasing the original left hand side state.
The destructor is also incorrect: it uses delete matrix_[k] instead of delete[] matrix_[k]. Conventionally objects are destroyed in the opposite order of construction while your code destroys objects in the opposite order. I'd recommend using std::vector<std::vector<T>> to maintain the data inside the Matrix<T>, too.