What's the difference between ways in assigning a pointer?

Question

Thank you for checking my question. I just encountered a really fundamental problem when I am implementing a BST, that is "what the difference in different approaches to assign a pointer?" We all know assign a point can use:

int *p, q;
p = &q;

Or:

int *p, *q;
p = q;

They should be the same. But in my case below, they working totally different:

template <typename T>
void Tree<T>::_insert(TreeNode<T>*& tree, const T& value, const unsigned& key)
{
//  TreeNode<T> node(value, key);
//  if(tree == nullptr) tree = &node;
    TreeNode<T> *node = new TreeNode<T>(value, key);
    if(tree == nullptr) tree = node;

    else if(key < tree->index) _insert(tree->left, value, key);
    else if(key > tree->index) _insert(tree->right, value, key);
    else if(key == tree->index) std::cerr << "_insert: repeating key" << std::endl;
}

Using the first way (noted one), the function won't assign tree equal to node, while the second way works fine.

So, is this my fault write, or they naturally different?

Answer 1

Please notice in the first case:

//  TreeNode<T> node(value, key);
//  if(tree == nullptr) tree = &node;

node is an object allocated on stack.

While in the second case

TreeNode<T> *node = new TreeNode<T>(value, key);
if(tree == nullptr) tree = node;

node is allocated on heap.

The difference is that once _insert function returns, its stack frame is poped, and all local variables/objects becomes invalid, as a result, you'll have memory errors.

Answer 2

No, the two ways should not be the same:

• The first assignment p = &q is perfectly valid, because q is the actual object in memory, and p is a pointer to it
• The second assignment p = q assigns an unitialized pointer q to p, which is undefined behavior.

That is why the two implementations are different.

If you would like to assign q to p, the q itself needs to be assigned first. For example, you could assign new int to it:

int *p, *q = new int;
p = q;

However, in this case you might as well assign new int directly to p.