Why does printing a pointer address trigger a breakpoint? - c++

Question

I am trying to implement a binary tree for learning purposes. When I first got the error I thought maybe I was deleting a node twice. Then I realised that even the print statement is triggering a breakpoint. There is no deletion anywhere else in the entire program so the problem has to be here.
here is BinaryTree.cpp
#include "BinaryTree.h"
#include<iostream>
BinaryTree::BinaryTree(void):root(nullptr){}
BinaryTree::~BinaryTree(void){removeWithChildren(root);}
void BinaryTree::insert(Node *n){
cout<<"\nInserting: "<<(void*)n;
Node *y = nullptr;
Node *x = root;
while(x != nullptr){
y = x;
if(n->key < x->key)
x = x->left;
else
x = x->right;
}
n->parent = y;
if(y == nullptr)
root = n;
else if (n->key < y->key)
y->left = n;
else
y->right = n;
}
void BinaryTree::removeWithChildren(Node *n){
//forgetChild(n);
if(n->left)
removeWithChildren(n->left);
if(n->right)
removeWithChildren(n->right);
cout<<"\nDeleting: "<<(void*)n;
delete n;
}
void BinaryTree::remove(Node *n){
if(n->left == nullptr) {
transplant(n,n->right);
} else if(n->right == nullptr) {
transplant(n,n->left);
} else {
Node *y = minimum(n->right);
if(y->parent != n){
transplant(y,y->right);
y->right = n->right;
y->left = n->left;
}
transplant(n,y);
y->left = n->left;
y->left->parent = y;
}
cout<<"\nDeleting: "<<(void*)n;
delete n;
}
void BinaryTree::transplant(Node *u,Node *v){
if(u->parent == nullptr) root = v;
else if (u == u->parent->left) u->parent->left = v;
else u->parent->right = v;
if(v) v->parent == u->parent;
}
string BinaryTree::prewalk(Node *n){
string output = "";
if(n!=nullptr){
output += prewalk(n->left);
output += prewalk(n->right);
output += to_string(n->key);
}
return output;
}
string BinaryTree::inwalk(Node *n){
string output = "";
if(n!=nullptr){
output += inwalk(n->left);
output += to_string(n->key);
output += inwalk(n->right);
}
return output;
}
Node* BinaryTree::search(Node *sub_tree,int key){
if(sub_tree == nullptr) return nullptr;
if(sub_tree->key == key) return sub_tree;
if(sub_tree->key < key) return search(sub_tree->right,key);
else return search(sub_tree->left,key);
}
Node* BinaryTree::getSuccessor(Node *n){
if(n->right)
return minimum(n->right);
Node *y = n->parent;
while(y){
if(n != y->right) break;
n = y;
y = y -> parent;
}
return y;
}
Node* BinaryTree::minimum(Node *sub_tree){
while(sub_tree->left)
sub_tree = sub_tree ->left;
return sub_tree;
}
Node* BinaryTree::maximum(Node *sub_tree){
while(sub_tree->right)
sub_tree = sub_tree ->right;
return sub_tree;
}
void BinaryTree::forgetChild(Node *n){
if(n->parent){
if(n == n->parent->left) n->parent->left = nullptr;
else n->parent->right = nullptr;
}
}
Here is main.cpp
#include"BinaryTree.h"
#include<iostream>
#include<random>
using namespace std;
int main(){
{
BinaryTree bt;
bt.insert(new Node(5));
bt.insert(new Node(1));
bt.insert(new Node(3));
bt.insert(new Node(4));
bt.insert(new Node(9));
//cout<<bt.inwalk(bt.getRoot())<<endl;
bt.remove(bt.search(bt.getRoot(),3));
//cout<<bt.inwalk(bt.getRoot())<<endl;
}
char x;cin>>x;
return 0;
}
Here is BinaryTree.h
#pragma once
#include<string>
using namespace std;
struct Node{
Node *left,*right,*parent;
int key;
Node():left(nullptr),right(nullptr),parent(nullptr),key(0) {}
Node(int x):left(nullptr),right(nullptr),parent(nullptr),key(x) {}
};
class BinaryTree
{
private:
Node *root;
public:
BinaryTree(void);
~BinaryTree(void);
Node* getRoot() { return root; }
void insert(Node *n);
void removeWithChildren(Node *n);
void remove(Node *n);
string prewalk(Node *n);
string inwalk(Node *n);
Node* search(Node *sub_tree,int key);
Node* minimum(Node *sub_tree);
Node* maximum(Node *sub_tree);
Node* getSuccessor(Node *n);
void forgetChild(Node *n);
void transplant(Node* u,Node*v);
};
The destructor calls the removeWithChildren(Node *n) function and the argument being the root of the tree.
I am calling the remove(Node *n) once. When I do not call it, there is no error. I stepped through and inspected the code, the removeWithChildren function is not trying to delete the node which was deleted by the remove function. Still there is an error.
EDIT: I am on Microsoft Visual Studio 2012 Express edition.
I don't know what kind of breakpoint.
EDIT2: Commenting out forgetChild in removeWithChildren fixes the error for some reason.

Answer 1

You did not post the relevant part of your code, but what you posted leads to the guess that you provided neither a valid copy constructor, nor any prevention of use of the default copy constructor. Then you made the mistake of passing an object by value (when you should have passed by reference) thus invoking the default copy constructor and the destructor and corrupting memory.
When working with classes for which copy construction is difficult and probably unnecessary, make sure the default copy constructor is not reachable.