Memory leak when using CString for tree node - c++

Question

I would like to save (serialize) an MFC tree control in a dialog and recall it to populate the tree when the dialog is initialized. I thought the way to approach that task would be to first code a program that creates a (preferably) vector representation of the tree, stores it in a text file, and then recreates the tree representation by deserializing from the saved file. I would also prefer to save the nodes as CStrings because that’s how I’m used to saving and reading text from files. However, not only can I not get to first base on this, I can’t even pick up the bat. The following minimal code to create a single node using std::string runs ok.
#include <string>
#include <vector>
// A node of N-ary tree
struct Node {
std::string key;
std::vector<Node*> child; // An array of pointers for children
};
// A utility function to create a new N-ary tree node
Node* newNode(std::string key)
{
Node* temp = new Node;
temp->key = key;
return temp;
}
// A utility function to create a tree
Node* createTree()
{
Node* root = newNode( "Root" );
return root;
}
int main()
{
Node* root = createTree();
return 0;
}
But if I change it to use CString instead,
#include <afx.h>
#include <tchar.h>
#include <vector>
struct Node {
CString key;
std::vector<Node*> child; // An array of pointers for children
};
Node* newNode(CString key)
{
Node* temp = new Node;
temp->key = key;
return temp;
}
Node* createTree()
{
Node* root = newNode( _T("Root") );
return root;
}
…when the program exits it reports a memory leak. Could someone please explain why, and what if anything I can do to correct it?

Answer 1

As the previous answer and comments noted, someone has to free all allocated memory.
When you use new, the responsibility is on you.
However, C++ provides smart pointers that can manage memory allocation and freeing for you; please see https://en.cppreference.com/w/cpp/memory/unique_ptr.
Your sample code will look like this:
#include <atlstr.h>
#include <tchar.h>
#include <vector>
#include <memory>
struct Node {
CString key;
std::vector<std::unique_ptr<Node>> child;
};
std::unique_ptr<Node> newNode(CString key)
{
std::unique_ptr<Node> temp = std::make_unique<Node>();
temp->key = key;
return temp;
}
std::unique_ptr<Node> createTree()
{
std::unique_ptr<Node> root = newNode(_T("Root"));
root->child.push_back(newNode(_T("Child")));
return root;
}
APPENDED per question in the comment:
CString encode(std::unique_ptr<Node>& root)
{
if (root == nullptr)
return _T("");
{
CString sRep = root->key;
for (auto& temp : root->child)
sRep += encode(temp);
return sRep += _T("|");
}
}

Answer 2

It appears you have a memory leak in your original iteration as well (without using CString). You allocate memory on the heap for a new Node in newNode(std::string), but you never call delete on that pointer anywhere.
Simply delete root; somewhere before main() exits to fix this first memory leak.
Next, you'll find that once you populate the vector<Node*> child with pointers, those will need to be deleted somehow as well. I suggest adding a destructor to your struct Node that iterates through vector and explicitly calls delete on each pointer in there.
A note on CString
A quick search about how CString works[1] (because I've never dealt with it before) indicates that when you make a copy of a CString (such as by using the copy assignment operator), a new object isn't created, but a reference counter is incremented in the original CString object. The object is only destroyed once that reference counter reaches zero.
Since you're never calling delete on your Node pointer, the CString object in the Node object is never deleted, and this reference number is never decreased. Calling delete should fix the problem, but please report back whether or not it does.