how to check if a pointer is unbound?

[Jess]

Hello,

I tried a program as follows:

include<iostrea m>

using namespace std;

class A{
public:
int x;
A():x(10){}
};

int main(){
A a;
A* p = &a;
A* q = p;
delete p;
cout << q << endl;
return 0;
}

Since "q" should be unbound, I thought the output would be "0".
However, the result was segmentation fault. How can I check if a
pointer is unbound?

Thanks,
Jess

[Clark Cox]

On 2007-05-22 15:07:10 -0700, "JohnQ"
<jo************ ***********@yah oo.comsaid:

>
"Jess" <wd***@hotmail. comwrote in message
news:11******** **************@ k79g2000hse.goo glegroups.com.. .

>Hello,

I tried a program as follows:

include<iostre am>

using namespace std;

class A{
public:
int x;
A():x(10){}
};

int main(){
A a;
A* p = &a;
A* q = p;
delete p;
cout << q << endl;
return 0;
}

Since "q" should be unbound, I thought the output would be "0".
However, the result was segmentation fault. How can I check if a
pointer is unbound?

Why doesn't/can't C++ set deleted pointers (and freed memory pointers
therefor) to null? It would seem that dereferencing a null pointer and
getting an exception is preferable than dereferencing and REusing a ptr and
not noticing that it had already been freed/deleted. (I know this has been
asked and answered before, but I forgot what the short answer is).

Because it isn't possible (without a garbage collector or some similar
mechanism) to track down all of the pointers that might point to or
into the same object:
int main()
{
int *p1 = new int;
int *p2 = p1;

delete p1;
//p2 still has old value
return 0;
}

--
Clark S. Cox III
cl*******@gmail .com

[JohnQ]

"Alf P. Steinbach" <al***@start.no wrote in message
news:5b******** *****@mid.indiv idual.net...

>* JohnQ:

>>
Why doesn't/can't C++ set deleted pointers (and freed memory pointers
therefor) to null? It would seem that dereferencing a null pointer and
getting an exception is preferable than dereferencing and REusing a ptr
and not noticing that it had already been freed/deleted. (I know this has
been asked and answered before, but I forgot what the short answer is).

C++ doesn't force that inefficiency on you,

I fail to see where the 'p = 0' added to delete and free would cause
inefficiency.

but it allows you to easily define that functionality yourself if you want
it:

template< typename T >
void destroy( T*& p ) { delete p; p = 0; }

I do this in my memory manager (set the pointer to 0). (Overridden global
new and delete operators).

(plus more overloads plus destroyArray).

It isn't necessarily a good idea.

The problem is that by relying on defined behavior that defined behavior
may easily be abused, resulting in nullpointer-checks everywhere.

Is what happens when one tries to dereference a ptr that has been "nulled"
platform-specific?.

John

[James Kanze]

On May 23, 12:16 am, "Alf P. Steinbach" <[e-mail] rote:

* JohnQ:

Why doesn't/can't C++ set deleted pointers (and freed memory pointers
therefor) to null? It would seem that dereferencing a null pointer and
getting an exception is preferable than dereferencing and REusing a ptrand
not noticing that it had already been freed/deleted. (I know this has been
asked and answered before, but I forgot what the short answer is).

C++ doesn't force that inefficiency on you, but it allows you to easily
define that functionality yourself if you want it:

template< typename T >
void destroy( T*& p ) { delete p; p = 0; }

(plus more overloads plus destroyArray).

The answer doesn't have much to do with efficiency, at least not
here. The answer is that just setting the argument to delete to
null doesn't help much (and of course, the argument to delete
isn't even necessarily an lvalue). In order to be helpful, it
would be necessary to set *all* of the pointer to the object to
null. And this isn't reasonably possible with the language
specified as it currently is, and maintaining any degree of C
compatibility. (It might be possible with "fat" pointers, with
each pointer linked back to the originating source of the
pointer in some way.)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Roland Pibinger]

On Tue, 22 May 2007 22:07:10 GMT, "JohnQ" wrote:

>Why doesn't/can't C++ set deleted pointers (and freed memory pointers
therefor) to null? It would seem that dereferencing a null pointer and
getting an exception is preferable than dereferencing and REusing a ptr and
not noticing that it had already been freed/deleted. (I know this has been
asked and answered before, but I forgot what the short answer is).

The short answer is that you should use delete only in a destructor.
--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

[Alf P. Steinbach]

* James Kanze:

On May 23, 12:16 am, "Alf P. Steinbach" <[e-mail] rote:

>* JohnQ:

>>Why doesn't/can't C++ set deleted pointers (and freed memory pointers
therefor) to null? It would seem that dereferencing a null pointer and
getting an exception is preferable than dereferencing and REusing a ptr and
not noticing that it had already been freed/deleted. (I know this has been
asked and answered before, but I forgot what the short answer is).

>C++ doesn't force that inefficiency on you, but it allows you to easily
define that functionality yourself if you want it:

> template< typename T >
void destroy( T*& p ) { delete p; p = 0; }

>(plus more overloads plus destroyArray).

The answer doesn't have much to do with efficiency, at least not
here. The answer is that just setting the argument to delete to
null doesn't help much (and of course, the argument to delete
isn't even necessarily an lvalue).

Nulling a pointer after delete can in some situations help find bugs,
and it can be done automatically when the argument is a non-const
lvalue. That's why it's often done by sloppy coders (Microsoft comes to
mind). What you call "the" answer is another aspect, which is also
relevant, but the inference

In order to be helpful, it
would be necessary to set *all* of the pointer to the object to
null.

is not valid -- one shouldn't refrain from detecting and correcting
bugs just because one can't detect and correct them all (not that I
endorse the technique of nulling pointers, but the argument is invalid).

Cheers,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Martijn van Buul]

* JohnQ:

> template< typename T >
void destroy( T*& p ) { delete p; p = 0; }

I do this in my memory manager (set the pointer to 0). (Overridden global
new and delete operators).

That is a noop, as void operator delete (void *) passes the pointer of the
to-be-released chunk by value, and not by reference. And even if it did,
it wouldn't work for objects being pointed to by multiple pointers.

--
Martijn van Buul - pi**@dohd.org

[Martijn van Buul]

* Roland Pibinger:

The short answer is that you should use delete only in a destructor.

That's short. And wrong.

--
Martijn van Buul - pi**@dohd.org

[Marcus Kwok]

JohnQ <jo************ ***********@yah oo.comwrote:

Why doesn't/can't C++ set deleted pointers (and freed memory pointers
therefor) to null?

See The Creator's FAQ:
http://www.research.att.com/~bs/bs_f...ml#delete-zero

--
Marcus Kwok
Replace 'invalid' with 'net' to reply

[Howard]

"Marcus Kwok" <ri******@gehen nom.invalidwrot e in message
news:f3******** **@news-int2.gatech.edu ...

JohnQ <jo************ ***********@yah oo.comwrote:

>Why doesn't/can't C++ set deleted pointers (and freed memory pointers
therefor) to null?

See The Creator's FAQ:
http://www.research.att.com/~bs/bs_f...ml#delete-zero

God has an FAQ now? :-)

-Howard

[JohnQ]

"Martijn van Buul" <pi**@dohd.orgw rote in message
news:sl******** **********@mud. stack.nl...

>* JohnQ:

>> template< typename T >
void destroy( T*& p ) { delete p; p = 0; }

I do this in my memory manager (set the pointer to 0). (Overridden global
new and delete operators).

That is a noop, as void operator delete (void *) passes the pointer of the
to-be-released chunk by value, and not by reference.

Maybe my compiler is accepting void*&?

And even if it did,
it wouldn't work for objects being pointed to by multiple pointers.

Understood. It's a caveat.

John