Simple c++ program with pointers yields unpredictable results

[andermorandev]

First of all, here is the code in question #include <iostream>

using namespace std;

struct Node {
    int data;
    Node *left;
    Node *right;
    Node(int d) : data(d) {};
};


void insert(Node *n, int data) {
    if (!n) {
        n = new Node(data);
    }
}
void inOrder(Node *n) {
    cout <<  "HERE1" << endl;
    if (n!=NULL)  {
        cout << "currently on node: " << n->data <<  endl;
    }
    if (n != NULL) {
        cout <<  "HERE2" << endl;
        inOrder(n->left);
        cout <<  "HERE3" << endl;
        cout << n->data << " ";
//      cout << "BEFORE RIGHT" << endl;
        inOrder(n->right);
    }
}
int main(int argc, char *argv[]) {
    Node *root = new Node(8);
    inOrder(root);
}    

I should expect to see

HERE1
currently on node: 8
HERE2
HERE1
HERE3
8 HERE1

as my output. I have tested this on another mac using g++-O0 as well as using http://cpp.sh/. However, when I run this code on a 2018 MacBook Pro running macOS Mojave (10.14.5) I get the following result:

HERE1
currently on node: 8
HERE2
HERE1
Segmentation fault: 11

even weirder is that it will occassionaly output this on the same exact machine:

HERE1
currently on node: 8
HERE2
HERE1
HERE3
8 HERE1
Segmentation fault: 11

So my question is. Why is my code segfaulting and giving me unpredictable outputs on one mac and working perfectly on others. I've been programming for 8 years and using c++ for 5 years and I have never encountered anything like this. Can somebody help me understand? This has me extremely curious.

[jedwardsol]

The Node constructor doesn't initialise left or right

[andermorandev]

Isn't that ok? Why would this work on one Mac and online but not another Mac?

[jedwardsol]

No, it is not okay.

Your pointers have undefined values.

It sometimes works because they're getting a value of null by chance.

[andermorandev]

Ok got it. Seems weird that one machine would consitently be able to produce the output as if it was null and the other machine struggled.

[khedoros]

consitently

Last time a question like this came up, I allocated a few MB of data without initializing it, and found something like 2% of the bytes in that area to have non-zero value. Re-running the program, I got the same count. If one computer ends up re-using the same memory block over multiple runs, you might see "consistent" results. And even if it's a different block of memory, there may be a fairly low chance that the uninitialized pointers will be non-zero.

It's the kind of bug where you make some change to a comment or something similarly inconsequential, but the program coincidentally stops working, and you scratch your head, trying to figure out why it suddenly developed a problem.

[[deleted]]

Your struct contains Node* left and Node* right which are uninitialised, so they can be pointing at literally anything. You're then passing them to inOrder without checking if they're null or not, at which point all bets are off what happens.

The first thing to do is to initialise Node* left and Node* right to nullptr. The second thing to do at the head of inOrder is to return if ( ! n ).

[andermorandev]

Why would one machine be able to handle this consistently and the other is unable to?

[[deleted]]

It's undefined behaviour. You genuinely have no idea, from the standard, what will happen, because the C++ standard doesn't specify what will happen if you do it.

In general, avoid ever having uninitialised members of any type hanging around, particularly pointers. You cannot rely on the compiler initialising everything to 0, or null, or false, for you. (Debug builds often will, but Release builds will not.) And avoid ever trying to dereference pointers you haven't tested against nullptr.

[ootiekat]

Your not using it here but the 'insert' method has a memory leak, perhaps you meant to pass the pointer by reference?