Looking for help with pointer idea.

Well, I don't really know how to explain this other than show you so that is what I'll do.

Code:

int* a = new int(1000);
int* b = a;

delete a; a = 0;

I know that doesn't make any sense, but what I am wanting to do is that when a is freed b is automatically set to NULL also.

I am also wanting to maintain the pointer syntax for the most part so I don't end up with another class that is unreadable. I also need to have it work on multiple levels. So basically

Code:

int* a = new int(1000);
int* b = a;
int* c = b;
//etc etc

I want c and b to be set to null when a is freed.

I have been thinking about this for several hours, but I have yet to come up with anything that lets me maintain the regular syntax.

- I don't care about allowing directly newing or deleteing the data as a function for this is fine
- I want to maintain the * and -> to access the data for getting/setting

I am hoping someone here can give me some insight/ideas on how to achieve this. I am very grateful for any assistance. Thank you.

Originally Posted by Raigne

I know that doesn't make any sense, but what I am wanting to do is that when a is freed b is automatically set to NULL also.

The solution is to use a std::tr1::shared_ptr instead of a raw pointer. (Or in the absence of a TR1 implementation, boost::shared_ptr.)

EDIT:
Actually, if only a has ownership while b (and c) does not, then a could be a std::tr1::shared_ptr while b (and c) would be a std::tr1::weak_ptr (or boost::weak_ptr, as the case may be).

About the second question, using:

int* &b = a;
int* &c = b;

Originally Posted by leiming

About the second question, using:

int* &b = a;
int* &c = b;

That will only work if b (and c) will never be bound to another pointer.

Originally Posted by laserlight

That will only work if b (and c) will never be bound to another pointer.

I just try writting some codes to reach it:

Code:

#include <iostream>
using namespace std;

class myintpointer{
	public:
		myintpointer(){
			p2 = 0;
			p = 0;
		}
		myintpointer(int* p){
			this->p = p;
			p2 = this;
		}
		operator int* (){
			if (p2==this)
				return p;
			else
				return *p2;
		}
		int* operator = (int *p){
			this->p = p;
			p2 = this;
		}
		myintpointer* operator = (myintpointer *p){
			p2 = p;
		}
	private:
		int *p;
		myintpointer *p2;
};

int main(){
	myintpointer a = new int;
	myintpointer b, c;
	*a = 1000;
	c = b;
	b = a;
	cout << *a << " " << *b << endl;
	delete a;
	c = new int(2000);
	b = c;
	cout << *c << " " << *b << endl;
	return 0;
}

I hope it helps.

Originally Posted by leiming

I just try writting some codes to reach it:

What do you mean? Your original suggestion seems pretty clear, just that it has a limitation that might not be relevant. (And it shares with Raigne's original code the disadvantage of having to do manual memory management.)

Originally Posted by laserlight

What do you mean? Your original suggestion seems pretty clear, just that it has a limitation that might not be relevant. (And it shares with Raigne's original code the disadvantage of having to do manual memory management.)

I mean if that shall work when b and c are bound to another pointer, this is the only way I can find.

It has no other meanings. And because English is not my native language; if there are something I misunderstand, I say sorry for that.