Advice on resolving memory leak with "new" keyword - c++

Question

I have a question on how to resolve a memory leak for an assignment in my c++ class. In this assignment, I am supposed to implement a BST. I have done so and functionality wise, everything works as I expected. However, I am have a memory leak in my program. The only problem is, when I try to debug my memory leak with Valgrind, I get pointed to a line in my compiled code that I did not write. In the function below, and I did not write this function, this was given to me by my professor, Valgrind points to the line NodeData* ptr = new NodeData(s); in the function below:
void buildTree(BinTree& T, ifstream& infile) {
string s;
for (;;) {
infile >> s;
cout << s << ' ';
if (s == "$$") break; // at end of one line
if (infile.eof()) break; // no more lines of data
NodeData* ptr = new NodeData(s); // NodeData constructor takes string
// would do a setData if there were more than a string
bool success = T.insert(ptr);
if (!success)
delete ptr; // duplicate case, not inserted
}
}
In the driver file for my BST, a file created by my professor, he is allocating NodeData pointers. The NodeData class was also given to me by the professor, but the problem (I think) is that the destructor for the NodeData class is empty. Here is the .cpp file for the NodeData class:
#include "nodedata.h"
//------------------- constructors/destructor -------------------------------
NodeData::NodeData() { data = ""; } // default
NodeData::~NodeData() { } // needed so strings are deleted properly
NodeData::NodeData(const NodeData& nd) { data = nd.data; } // copy
NodeData::NodeData(const string& s) { data = s; } // cast string to NodeData
//------------------------- operator= ----------------------------------------
NodeData& NodeData::operator=(const NodeData& rhs) {
if (this != &rhs) {
data = rhs.data;
}
return *this;
}
//------------------------- operator==,!= ------------------------------------
bool NodeData::operator==(const NodeData& rhs) const {
return data == rhs.data;
}
bool NodeData::operator!=(const NodeData& rhs) const {
return data != rhs.data;
}
//------------------------ operator<,>,<=,>= ---------------------------------
bool NodeData::operator<(const NodeData& rhs) const {
return data < rhs.data;
}
bool NodeData::operator>(const NodeData& rhs) const {
return data > rhs.data;
}
bool NodeData::operator<=(const NodeData& rhs) const {
return data <= rhs.data;
}
bool NodeData::operator>=(const NodeData& rhs) const {
return data >= rhs.data;
}
//------------------------------ setData -------------------------------------
// returns true if the data is set, false when bad data, i.e., is eof
bool NodeData::setData(istream& infile) {
getline(infile, data);
return !infile.eof(); // eof function is true when eof char is read
}
//-------------------------- operator<< --------------------------------------
ostream& operator<<(ostream& output, const NodeData& nd) {
output << nd.data;
return output;
}
Its pretty short, but you can see that the destructor is empty. I dont know if I am allowed to edit the destructor of NodeData to resolve this memory leak and I am not sure how/where else in my code I can delete these pointers (as I cannot edit the driver file itself either). This isnt something I have ever dealt with before and what I need help with. Can someone help me out with this and give me suggestions on ways that I can investigate on how to resolve this memory leak?
Is it possible to resolve the memory leak caused by not deleting the pointers created by: NodeData* ptr = new NodeData(s); in the function the pointers are being passed to (the insert function. I can provide this code if needed).
If it is not possible to resolve the memory leak inside the insert function, is there another place I can feasibly fix it? I think I might be able to edit the NodeData class/make a destructor, but am not totally sure on how to implement such a destructor function in the NodeData class.
And as it is probably helpful, here is the insert function of the BinTree class that is referenced by the buildTree function:
bool BinTree::insert(NodeData* nodeData){
if(root != nullptr){ //if the root of the tree is not NULL, meaning that the BST object exists, we call our insertHelp function.
insertHelp(this->root, nodeData);
return true;
}
else{ //If there is no root node created in our tree, we create a root node.
root = new Node;
root->left = nullptr;
root->right = nullptr;
root->data = nodeData;
return true;
}
return true;
}
// ---------------------------------insertHelp--------------------------------------------------
// Description: Private function that recursively calls itself in order to find the correct location in a BinTree object to add a new node.
// ---------------------------------------------------------------------------------------------------
bool BinTree::insertHelp(Node *nodePointer, NodeData* nodeData){
if(*nodeData < *nodePointer->data){ //Here we are deciding if we need to traverse left or not.
if(nodePointer->left != nullptr){ //If there is a node to the left, we call insertHelper again but on this node to the left.
insertHelp(nodePointer->left, nodeData);
}
else{ //if there is no node the left, and we need to go left, we create a new left node.
nodePointer->left = new Node;
nodePointer->left->left = nullptr;
nodePointer->left->right = nullptr;
nodePointer->left->data = nodeData;
return true;
}
}
else if(*nodeData > *nodePointer->data){//Here we are deciding if we need to traverse right or not.
if(nodePointer->right != nullptr){ //if there is no node the right, and we need to go left, we create a new left node.
insertHelp(nodePointer->right, nodeData);
}
else{ //if there is no node the right, and we need to go right, we create a new right node.
nodePointer->right = new Node;
nodePointer->right->left = nullptr;
nodePointer->right->right = nullptr;
nodePointer->right->data = nodeData;
return true;
}
}
else{ //catch all case. If something goes wrong, return false.
return false;
}
return true;
}
Here is the current destructor for BinTree:
BinTree::~BinTree(){
makeEmpty();
}
void BinTree::makeEmpty(){
//You make a tree empty by deleting all notes in a post-order traversal.
postOrderDeleteNode(this->root); //I will call my private postOrderDelete helper function. I broke things up this way to make the code cleaner.
}
// ---------------------------------postOrderDeleteNode--------------------------------------------------
// Description: This is the private function that performs a post-order traversal of the nodes in a BinTree
// and deletes each node by deallocating the memory assigned when each node is created.
// ---------------------------------------------------------------------------------------------------
void BinTree::postOrderDeleteNode(const Node *rootNode){
if(rootNode == nullptr){ //Base case, we have an empty tree at this node
return;
}
else{
postOrderDeleteNode(rootNode->left); //First we delete the left side of the tree
postOrderDeleteNode(rootNode->right); //Then we delete the right side of the tree.
delete rootNode; //We finally delete the root of the entire BST.
this->root = nullptr;
}
}
And here is the .h file for BinTree:
// ------------------------------------------------bintree.h-------------------------------------------------------
//
// Programmer Name: Aviv Weinstein
// Course Section Number: CSS 502 A
// Creation Date: 1/17/21
// Date of Last Modification: 1/27/21
// Instructor Name: Professor Dong Si
// --------------------------------------------------------------------------------------------------------------------
// Purpose -
// --------------------------------------------------------------------------------------------------------------------
// Notes on specifications, special algorithms, and assumptions:
// --------------------------------------------------------------------------------------------------------------------
#ifndef Bintree_H
#define Bintree_H
#include "nodedata.h"
//We have inlcuded iostream in nodedata.h
using namespace std;
class BinTree{
friend ostream& operator<<(ostream& out, const BinTree& T); //Used for output printing of BinTree objects. To display the tree using inorder traversal.
public:
BinTree(); // constructor
BinTree(const BinTree &); // copy constructor
~BinTree(); // destructor, calls makeEmpty
bool isEmpty() const; // true if tree is empty, otherwise false
void makeEmpty(); // make the tree empty so isEmpty returns true
BinTree& operator=(const BinTree &); //The assignment operator (=) to assign one tree to another
bool operator==(const BinTree &) const; //Boolean comparison operator for equal
bool operator!=(const BinTree &) const; //Boolean comparison operator for NOT equal
bool insert(NodeData*); //inserts a new node, with NodeData, into the BinTree object.
bool retrieve(const NodeData &, NodeData* &) const; //Looks for a specific node in the BinTree. Returns true if the node exists.
void displaySideways() const; // provided below, displays the tree sideways
int getHeight(const NodeData &) const; //function to find the height of a given value in the tree.
void bstreeToArray(NodeData* []); //function to fill an array of Nodedata* by using an inorder traversal of the tree
void arrayToBSTree(NodeData* []); //function to fill an array of Nodedata* by using an inorder traversal of the tree
private:
struct Node {
NodeData* data; // pointer to data object
Node* left; // left subtree pointer
Node* right; // right subtree pointer
};
Node* root; // root of the tree
//Utility functions
void sideways(Node*, int) const; //provided below, helper for displaySideways()
bool insertHelp(Node *nodePointer, NodeData* nodeData); //Helper function for the insert function.
void postOrderDeleteNode(const Node *node); // Helper function. Deletes all nodes in a BinTree object
void inorderHelper(Node *startNode) const; //Helper function for printing out all nodes in a BST using in-order traversal
void inorderHelperArray(NodeData* a[], Node *startNode) const; //Helper function for the operator == and operator!= functions.
//Used to compare BSTs to each other using in-order traversal.
Node* retrieveHelper(Node *root, const NodeData &nodeData) const; //A hlper function for retriving a node in a BinTree
int getHeightUtil(Node *node)const; //Helper for performing a recursive calculation of the height of a node in a BinTree.
void preorderTraversal(Node* node); //Performs a pre-order traversal of a BinTree object. Called by the operator= function.
void convert(NodeData* a[], int start, int end, Node *root); //Performs a utility function in the arraytoBSTree function.
//Selects the correct array indexes to be added next into an array.
};
#endif

Answer 1

Every time you call new, there must be corresponding delete for it. In your example, you call new, then store node in BinTree. I think you do not delete this node from BinTree once tree gets deallocated. Storing std::shared_ptr instead of raw pointer will resolve this problem.
It is always better to use automatic memory management
void buildTree(BinTree& T, ifstream& infile) {
string s;
for (;;) {
infile >> s;
cout << s << ' ';
if (s == "$$") break; // at end of one line
if (infile.eof()) break; // no more lines of data
// ptr will be removed automatically when it goes out of scope
std::shared_ptr<NodeData> ptr = std::make_shared<NodeData>(s);
// would do a setData if there were more than a string
// tree insertion would increase ptr scope to the scope of a T instance,
// so if T is deallocated, all nodes will be deallocated automatically
T.insert(ptr);
}
}
If, for some reason, you do not want/can't use shared_ptr, then change nothing in buildTree and make BinTree::insert convert raw pointer to std::shared_ptr inside:
bool BinTree::insert(NodeData* nodeData){
if(root != nullptr){ //if the root of the tree is not NULL, meaning that the BST object exists, we call our insertHelp function.
insertHelp(this->root, nodeData);
return true;
}
else{ //If there is no root node created in our tree, we create a root node.
root = new Node;
root->left = nullptr;
root->right = nullptr;
// update ---vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
root->data = std::shared_ptr<NodeData>(nodeData);
return true;
}
return true;
}
bool BinTree::insertHelp(Node *nodePointer, NodeData* nodeData){
if(*nodeData < *nodePointer->data){ //Here we are deciding if we need to traverse left or not.
if(nodePointer->left != nullptr){ //If there is a node to the left, we call insertHelper again but on this node to the left.
insertHelp(nodePointer->left, nodeData);
}
else{ //if there is no node the left, and we need to go left, we create a new left node.
nodePointer->left = new Node;
if(!nodePointer->left) return false;
nodePointer->left->left = nullptr;
nodePointer->left->right = nullptr;
nodePointer->left->data = std::shared_ptr<NodeData>(nodeData);
return true;
}
}
else if(*nodeData > *nodePointer->data){//Here we are deciding if we need to traverse right or not.
if(nodePointer->right != nullptr){ //if there is no node the right, and we need to go left, we create a new left node.
insertHelp(nodePointer->right, nodeData);
}
else{ //if there is no node the right, and we need to go right, we create a new right node.
nodePointer->right = new Node;
if(!nodePointer->right) return false;
nodePointer->right->left = nullptr;
nodePointer->right->right = nullptr;
nodePointer->right->data = std::shared_ptr<NodeData>(nodeData);
return true;
}
}
else{ //catch all case. If something goes wrong, return false.
return false;
}
return true;
}

Answer 2

This comes down to a bug in your insertHelp and insert functions as well as the fact that you do not delete the data object of your node.
If you take a close look at insert, you'll notice that it always returns true so even if you attempt to insert a duplicate, buildTree never deletes that object.
// we need to take the return values of the recursive calls in this function
bool BinTree::insertHelp(Node* nodePointer, NodeData* nodeData) {
if (*nodeData < *nodePointer->data) { //Here we are deciding if we need to traverse left or not.
if (nodePointer->left != nullptr) { //If there is a node to the left, we call insertHelper again but on this node to the left.
return insertHelp(nodePointer->left, nodeData);
}
else { //if there is no node the left, and we need to go left, we create a new left node.
nodePointer->left = new Node;
nodePointer->left->left = nullptr;
nodePointer->left->right = nullptr;
nodePointer->left->data = nodeData;
return true;
}
}
else if (*nodeData > *nodePointer->data) {//Here we are deciding if we need to traverse right or not.
if (nodePointer->right != nullptr) { //if there is no node the right, and we need to go left, we create a new left node.
return insertHelp(nodePointer->right, nodeData);
}
else { //if there is no node the right, and we need to go right, we create a new right node.
nodePointer->right = new Node;
nodePointer->right->left = nullptr;
nodePointer->right->right = nullptr;
nodePointer->right->data = nodeData;
return true;
}
}
else { //catch all case. If something goes wrong, return false.
return false;
}
return true;
}
bool BinTree::insert(NodeData* nodeData) {
if (root != nullptr) { //if the root of the tree is not NULL, meaning that the BST object exists, we call our insertHelp function.
return insertHelp(this->root, nodeData); // <<<<<<<<<<<<<<< use the return value of the helper function here!!!
}
else { //If there is no root node created in our tree, we create a root node.
root = new Node;
root->left = nullptr;
root->right = nullptr;
root->data = nodeData;
return true;
}
return true;
}
void BinTree::makeEmpty() {
//You make a tree empty by deleting all notes in a post-order traversal.
postOrderDeleteNode(this->root); //I will call my private postOrderDelete helper function. I broke things up this way to make the code cleaner.
this->root = nullptr; // needs to be done just once
}
// ---------------------------------postOrderDeleteNode--------------------------------------------------
// Description: This is the private function that performs a post-order traversal of the nodes in a BinTree
// and deletes each node by deallocating the memory assigned when each node is created.
// ---------------------------------------------------------------------------------------------------
void BinTree::postOrderDeleteNode(const Node* rootNode) {
if (rootNode == nullptr) { //Base case, we have an empty tree at this node
return;
}
else {
postOrderDeleteNode(rootNode->left); //First we delete the left side of the tree
postOrderDeleteNode(rootNode->right); //Then we delete the right side of the tree.
delete rootNode->data; // <<<<<<<<<<<<<<<<<<<<<<<< delete the data too!!!!
delete rootNode; //We finally delete the root of the entire BST.
// set root to null it in makeEmpty() instead
}
}