稳定的Valgrind输出

Question

I wrote the following code to get a basic understanding of Valgrind and having a hard time interpreting its output. This probably is not related to Valgrind but more basic C++.

#include <string>
#include <iostream>
using namespace std;

class Valgrind_testclass
{
std::string * stringInHeap;

public:
  Valgrind_testclass() { 
    stringInHeap = new std::string("String in heap");   
  }
  ~Valgrind_testclass() {
    //delete stringInHeap;                  
  }

  void PrintFunc(void) {
    cout << "Nothing but a printout" << endl;
  }
};

int main()
{
 Valgrind_testclass * valObjPtr = new Valgrind_testclass();  
 delete valObjPtr;               
 return 0;
}

Valgrind outputs:

==4459== HEAP SUMMARY:
==4459==     in use at exit: 31 bytes in 2 blocks
==4459==   total heap usage: 3 allocs, 1 frees, 35 bytes allocated
==4459== 
==4459== Searching for pointers to 2 not-freed blocks
==4459== Checked 102,100 bytes
==4459== 
==4459== 31 (4 direct, 27 indirect) bytes in 1 blocks are definitely lost in loss record 2 of 2
==4459==    at 0x402641D: operator new(unsigned int) (vg_replace_malloc.c:255)
==4459==    by 0x80487DB: Valgrind_testclass::Valgrind_testclass() (in /home/madu/C++/ValgrindTest)
==4459==    by 0x80486F6: main (in /home/madu/C++/ValgrindTest)
==4459== 
==4459== LEAK SUMMARY:
==4459==    definitely lost: 4 bytes in 1 blocks
==4459==    indirectly lost: 27 bytes in 1 blocks
==4459==      possibly lost: 0 bytes in 0 blocks
==4459==    still reachable: 0 bytes in 0 blocks
==4459==         suppressed: 0 bytes in 0 blocks
==4459== 
==4459== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 17 from 6)

Could someone please tell me where I do 3 allocations? I can only see two allocations. Also why it says "indirectly lost"?

Thank you.

Answer 1

When you construct an std::string object, it allocates another pointer (internal to the object) to point to the string value. This is where the third allocation is coming from, and is also the indirectly-leaked memory.

In other words, you have these three allocations:

1. new Valgrind_testclass() (explicit)
2. new std::string("String in heap") (explicit)
3. The string-internal allocation (implicit / indirect)

Since you leaked allocation 2, you indirectly leaked allocation 3 as well; the string's destructor will not be called, and therefore it has no opportunity to free allocation 3.

Answer 2

You have 3 allocations because std::string also allocates memory.

Indirectly lost, means that you lost a pointer to something that had a pointer to some other memory. In this case, you didn't delete stringInHeap , and you lost its pointer. Through that, the actual std::string who had allocated memory could not delete it and therefore that memory is also lost.