Is there a way to check for this memory leak?

Question

I have a very basic function bool read_binary( string filename, double*& buf, int &N) which reads data from a binary file. I call it as:

int N;
double* A = NULL;
read_binfile(inputfile, A, N);
delete[] A;

where read_binfile is

bool read_binfile( string fname, double*& buf, int &N ) { 
    ifstream finp(fname.c_str(), ifstream::binary);

    finp.seekg(0, finp.end);
    N = finp.tellg()/8;
    buf = new double[N];
    finp.seekg(0, finp.beg);
    printf("N = %i\n", N); 
    finp.read( reinterpret_cast<char*>(buf), sizeof(buf[0])*N);

    if( finp ) {
        return true;
    } else {
        return false;
    }
}

I find that if I (naively) loop only read_binfile then this causes a memory leak, whereas if I include double* A = NULL and delete[] A in the loop, then this leak does not occur. Is there any way (inside of read_binfile) to check on this type of error or does this necessitate a correct use of read_binfile where a delete[] must follow without being called again?

Use a `std::vector` and then you don't have to worry about it. — NathanOliver, Jan 14 '16 at 19:44
`vector` does not assure that the memory is contiguous and I need to leverage locality in the algorithm. — drjrm3, Jan 14 '16 at 19:44
@Laurbert515 vector has been gauranteed since at least c++11 to be contiguous — NathanOliver, Jan 14 '16 at 19:48
@NathanOliver: Since C++03 actually, if I'm understanding the above link properly — Dark Falcon, Jan 14 '16 at 19:48
@DarkFalcon I didn't have that one available but I had C++11. — NathanOliver, Jan 14 '16 at 19:49
@Laurbert515, avoid use of hard coded size 8. Replace `N = finp.tellg()/8;` by `N = finp.tellg()/sizeof(double);`. — R Sahu, Jan 14 '16 at 19:51
@DarkFalcon Just got a C++03 standard. It is guaranteed in C++03 as well. — NathanOliver, Jan 14 '16 at 19:51
@NathanOliver, vector was guaranteed to be contiguous since it's inception. Even in 98. That was it's basic feature, without that, it would not be a replacement for C array. — SergeyA, Jan 14 '16 at 20:03
Are multi-dimensioned `vectors` given the same guarantee? I just went back to some old sites and found that only a 1-D vector has this guarantee - is this correct? Perhaps that is what I was thinking and was the source of my confusion here. — drjrm3, Jan 14 '16 at 20:23
@Laurbert515, every vector allocates contiguos space,but two independent vectors are not contiguos to each other. Hint - vector elements of vector are independent! — SergeyA, Jan 14 '16 at 22:58

score 2 · Accepted Answer · answered Jan 14 '16 at 20:00

You can use a std::vector<double> for buf. That will automate memory management. Then, you won't need to pass N as an argument either. You can get the size of the buffer from the vector.

bool read_binfile(std::string const& fname,
                  std::vector<double>& buf)
{
   std::ifstream finp(fname.c_str(), std::ifstream::binary);

   finp.seekg(0, finp.end);
   size_t N = finp.tellg()/sizeof(buf[0]);
   buf.resize(N);

   finp.seekg(0, finp.beg);
   finp.read(reinterpret_cast<char*>(buf.data()), sizeof(buf[0])*N);

   if( finp ) {
      return true;
   } else {
      return false;
   }
}

And use it as:

std::vector<double> A;
read_binfile(inputfile, A);
size_t N = A.size(); // Only if needed.

Is there a way to check for this memory leak?

1 Answers1