Question about address in the pointer mémoria

Question

I put a Cout in the way insertRight to verify the memory addresses of node1 (of the variable itself and not of what she keeps) and to my surprise the addresses shown repeated several times, as shown below.

004FF97C
004FF97C
004FF894
004FF97C
004FF894
004FF7AC
004FF97C
004FF894
004FF7AC
004FF6C4

Note that one of the local pointers has the same address in two consecutive calls to function insertRight

Because they are local pointers and therefore local variables (I believe, am I right?) , they should not be destroyed at the end of the method execution and be allocated to another memory address in the stack in a future call ?

Code:

Nodetree. h

class NodeTree
{
public:
    int value;
    NodeTree *right;
    NodeTree *left;

    NodeTree() {
        value = 0;
    }
};

---

Binarytree. h

#include <iostream>
using std::cout;
using std::endl;
#include "NodeTree.h"


class BinaryTree
{
public:
    NodeTree * root;
    BinaryTree();
    void insert(int);
    void insertRight(NodeTree *, NodeTree **);
};

---

Binarytree.cpp

#include "BinaryTree.h"

BinaryTree::BinaryTree() {
    root = NULL;
}

void BinaryTree::insert(int num) {

    NodeTree *node = new NodeTree;
    node->value = num;
    insertRight(node, &root);
}

void BinaryTree::insertRight(NodeTree *node1, NodeTree **root1)
{
    cout << &node1 << endl;

    if (*root1 == NULL) {
        node1->left = NULL;
        node1->right = NULL;
        *root1 = node1;
    }
    else {
        insertRight(node1, &(*root1)->right);
    }
}

---

Teste_pointers.cpp

#include "BinaryTree.h"

int main()
{   
    BinaryTree tree;
    tree.insert(5);
    tree.insert(10);
    tree.insert(15);
    tree.insert(20);
    tree.printInOrder(tree.root);
    return 0;
}

Answer 1

Starting with the first statement you made:

and to my surprise the address shown repeated several times

This is expected for the code you have, the insertRight, 'cause every time you’re about to make an insertion, you start at the root and navigate right until you catch a zero. Soon it will start 4 times to navigate through the root, causing the root node to be shown 4 times. If you had placed a visual separator between each insertion as a \n it would have been easier to interpret the result.

See the impression you have, identifying each node and each insert:

004FF97C //insert 1 raiz
004FF97C //insert 2 raiz
004FF894 //insert 2 raiz->direita
004FF97C //insert 3 raiz
004FF894 //insert 3 raiz->direita
004FF7AC //insert 3 raiz->direita->direita
004FF97C //insert 4 raiz
004FF894 //insert 4 raiz->direita
004FF7AC //insert 4 raiz->direita->direita
004FF6C4 //insert 4 raiz->direita->direita->direita

Let us now turn to the question you raised later:

Because they are local pointers and therefore local variables (I believe, am I right?) they should not be destroyed at the end of the method execution and have other addresses in a future call ?

Pointers are local but the created object is not, and can confirm this by creating with the operator new that allocates memory in the heap and not in the stack:

void BinaryTree::insert(int num) {

    NodeTree *node = new NodeTree;

So objects are allocated in memory and keep the same address until they are destroyed with the operator delete. The local pointer NodeTree *node which he created is destroyed but the object to which he points is not, so he can access it with any other pointer pointing to the same location.

Even you keep that pointer in a field of your class when you do *root1 = node1; within the function insertRight.

Also note that if it was not allocated with the new the object would be destroyed at the end of the function, but this already made its code incorrect and presenting undefined behavior, and that with bad luck could even work. So if you’re going to use objects you created in a function somewhere else you need them to be allocated in the heap through the new.