Checking unitialized class pointer

[cunnus88]

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:

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

It doesn't seem to work with classes.

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.

[Daved]

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++.

[cunnus88]

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

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

[Ancient Dragon]

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)

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

[Daved]

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.

[cunnus88]

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

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:

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)

[Daved]

Use the constructor to initialize the pointers to null.

[cunnus88]

Ah, that worked.

Thanks.