返回字符串时可能发生内存泄漏？

Question

I use valgrind --leak-check=full check my program, and got a leak which I have no idea with:

==6072== 54 bytes in 2 blocks are possibly lost in loss record 15 of 28
==6072==    at 0x4C2AF8E: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6072==    by 0x55B63B8: std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator<char> const&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.17)
==6072==    by 0x55B7D94: char* std::string::_S_construct<char const*>(char const*, char const*, std::allocator<char> const&, std::forward_iterator_tag) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.17)
==6072==    by 0x55B7E72: std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(char const*, std::allocator<char> const&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.17)
==6072==    by 0x4268ED: Writable::readString(std::istream*) (Writable.cpp:33)

Here's my code snippet:

#include "Writable.h"

Writable::Writable()
{
    //ctor
}

Writable::~Writable()
{
    //dtor
}


void Writable::writeString(ostream* ofs, string str){
    int length = str.size()+1;

    ofs->write((char*)&length, sizeof(length));

    if (length > 1)
        ofs->write(str.c_str(), length);

}

string Writable::readString(istream* ifs) {
    int length = 0;

    ifs->read((char*)&length, sizeof(length));

    if(length > 1) {
        char buf[length];
        ifs->read(buf, length);

        return string(buf);
    }

    return string("");
}

It's pointing to the "return string(buf)" line. Can you figure out how the leak is done there?

Cheers

Answer 1

Okay, I am not really sure what you are trying to do here. For your writeString method (why should it be a method if it does not use any members?), you should pass the stream as reference, and your string as constant reference. Your code could be simplified to this:

void Writable::writeString(std::ostream & ofs, std::string const & str){
    ofs << str;
}

No need to fiddle with pointers and buffers yourself if the standard already does that for you.

As for your readString "method": It seems you try to read 4 characters ( sizeof(length) ) and store them in length . If you have 4 characters, say "abcd", your length variable contains the bit pattern 41424344 (hexadecimal). In decimal, this is 1094861636 . Basically, you then try to read the next billion characters from your stream (after the abcd you extracted earlier). It is quite likely that your stream does not contain one billion characters, so a good portion of your buffer will be left uninitialized. If you are lucky, you find a NULL character somewhere which terminates your stream.

I do not know if you want to read the entire stream or just a line. In the latter case, you could simplify your code to:

std::string Writable::readString(std::ostream & ofs){
    std::string extracted;
    getline(ofs, extracted);
    return std::move(extracted); // or return extracted; if you have a pre C++11 compiler
}

Hope this helps.