Checking unitialized class pointer

Hello.

Is there a way to check if a pointer to a class has been initialized or not?

For example with a struct, you can do the following:

Code:

---

struct some_struct* s;
if(s == NULL)
{
...statement...
}

---

It doesn't seem to work with classes.

Code:

---

class some_class
{
...
};
some_class* s;
if(s == NULL)
{
...
}

---

The execution never stops at the conditional.

So how do you check if a class pointer has been initialized or not?

Thanks.

In both cases, if s is declared globally, it should work (because global pointer variables are initialized to 0 if you don't initialize them explicitly). In both cases, if s is declared local to a class or function, then they may or may not work, since you are using an uninitialized variable.

There is no difference in these cases between a struct and a class. If you see a difference, it is just lucky (or potentially due to some compiler specific differences between C and C++).

Also, you don't need the keyword struct in your code in C++.

Then, is there some surefire way to check if it has been initialized?

Does c++ have some kind of native function like "IsInitialized()"?

maybe you just onitted this for brievity, but you should set pointers to 0 or NULL when declared because the compiler will NOT do that for you (unless its a global or static variable)

Code:

---

struct some_struct* s = 0;
if(s == NULL)
{
...statement...
}

---

No, C++ does not keep track of what variables are uninitialized for you. Just remember to initialize them as Ancient Dragon showed. With pointers it is especially easy.

Here's the complete class definition I'm tinkering with:

Code:

---

class node
{
        int data;
        node* left = NULL; // causes error here after I inserted the NULL per dragon's instructions
        node* right = NULL; // ditto
public:
        int lookup(node*, int);
        void insert(node*, int);
        void set(int i){data = i;}
};

int node::lookup(node* n, int target)
{
        if(n==NULL) // the execution just bypasses this conditional even when n is unitialized.
        {
                return(false);
        }
        else
        {
                if(n->data == target) return(true);
                {
                        if(n->data > target) lookup(n->right, target);
                        else lookup(n->left, target);
                }
        }
}

void node::insert(node* n, int input)
{
        if(n == NULL)
        {
                n = new node;
                data = input;
        }
        if(input > n->data)
        {
                insert(n->right, input);
        }
        else
        {
                insert(n->left, input);
        }
}

---

This is actually the modification of a bit of code in a tutorial I got on the internet:

Code:

---

struct node {
int data;
struct node* left;
struct node* right;
};

static int lookup(struct node* n, int target) {
        // 1. Base case == empty tree
        // in that case, the target is not found so return false
        if (n == NULL) {
                return(false);
                }
        else {
                // 2. see if found here
                if (target == n->data) return(true);
                else {
                        // 3. otherwise recur down the correct subtree
                        if (target < n->data) return(lookup(n->left, target));
                        else return(lookup(n->right, target));
                }
        }
}

struct node* NewNode(int data) {
        struct node* n = new(struct node); // "new" is like "malloc"
        n->data = data;
        n->left = NULL;
        n->right = NULL;
        return(n);
}

struct node* insert(struct node* n, int data) {
        // 1. If the tree is empty, return a new, single node
        if (n == NULL) {
                return(NewNode(data));
        }
        else {
                // 2. Otherwise, recur down the tree
                if (data <= n->data) n->left = insert(n->left, data);
                else n->right = insert(n->right, data);
                return(n); // return the (unchanged) node pointer
        }
}

---

So at the moment, I have no idea whether my modification is fundamentally wrong or not because I can't even get it to work with the conditional. (BTW, I'm using VC++ 2003)

Use the constructor to initialize the pointers to null.

Ah, that worked.

Thanks.