Is this a valid delete

[Ninan]

I am skipping a couple of steps in betweens, like inserting into a list
of ints and extracting from it. But this is the gist of what I am
trying to do

class A {

};

A *a = new A();

int b = (int )a;

delete (A *)b;

Is this equivalent to
delete a?

My code seems to work fine

[Phlip]

Ninan wrote:

I am skipping a couple of steps in betweens, like inserting into a list
of ints and extracting from it. But this is the gist of what I am
trying to do

class A {

};

A *a = new A();

int b = (int )a;

delete (A *)b;

Is this equivalent to
delete a?

Tip: Replace all C-style casts with C++ casts.

In this case, you must use reinterpret_cas t<>.

I suspect the Standard requires your compiler to define the act of
reinterpretting something to another type, and then back to the same type.
If so, then the delete is valid.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[roberts.noah]

Phlip wrote:

Ninan wrote:

I am skipping a couple of steps in betweens, like inserting into a list
of ints and extracting from it. But this is the gist of what I am
trying to do

class A {

};

A *a = new A();

int b = (int )a;

delete (A *)b;

Is this equivalent to
delete a?

Tip: Replace all C-style casts with C++ casts.

In this case, you must use reinterpret_cas t<>.

I suspect the Standard requires your compiler to define the act of
reinterpretting something to another type, and then back to the same type.
If so, then the delete is valid.

Yes, the standard states that reinterpret_cas t from a pointer to an
integral and then back to the same pointer results in a pointer of the
original value if the integral is large enough to hold the value of the
pointer. This is in 5.2.10 parts 4&5.

On the other hand, I don't know that reinterpret_cas t is guaranteed to
be the operation of the above C-Style casts. Could be...better just to
use C++ style casts and be positive of what is going on.

[Victor Bazarov]

Phlip wrote:

Ninan wrote:

I am skipping a couple of steps in betweens, like inserting into a list
of ints and extracting from it. But this is the gist of what I am
trying to do

class A {

};

A *a = new A();

int b = (int )a;

delete (A *)b;

Is this equivalent to
delete a?

Tip: Replace all C-style casts with C++ casts.

In this case, you must use reinterpret_cas t<>.

I suspect the Standard requires your compiler to define the act of
reinterpretting something to another type, and then back to the same type.
If so, then the delete is valid.

The only potential problem is that a pointer to A may not fit into an int.
You _have_ to pick an integral value _large_enough_. Just think 32-bit
ints on a 64-bit system (with 64-bit pointers).

V
--
Please remove capital As from my address when replying by mail

[peter koch]

Ninan skrev:

I am skipping a couple of steps in betweens, like inserting into a list
of ints and extracting from it. But this is the gist of what I am
trying to do

class A {

};

A *a = new A();

int b = (int )a;

delete (A *)b;

Is this equivalent to
delete a?
Nope. This is not guaranteed to work. There is no guarantee that a
pointer can be represented in an integer. Most probably there will be
some integer type that can be used to keep a pointer, but I doubt that
this is guaranteed by the standard.
I wonder what rationale you have to "disguise" your pointers the way
you do - perhaps it could be some opaque interface?

/Peter
My code seems to work fine

[Ninan]

peter koch wrote:

Ninan skrev:

I am skipping a couple of steps in betweens, like inserting into a list
of ints and extracting from it. But this is the gist of what I am
trying to do

class A {

};

A *a = new A();

int b = (int )a;

delete (A *)b;

Is this equivalent to
delete a?

Nope. This is not guaranteed to work. There is no guarantee that a
pointer can be represented in an integer. Most probably there will be
some integer type that can be used to keep a pointer, but I doubt that
this is guaranteed by the standard.
I wonder what rationale you have to "disguise" your pointers the way
you do - perhaps it could be some opaque interface?

/Peter

My code seems to work fine

I should confess that I am not the inventor of this code. It belongs to
someone who left the job and whose work I have taken over
But rationale is some thing like this. The pointers to classes are
inserted into a list of integers. At a future point in time the
contents of the classes are converted (streamed) to socket messages and
sent over the network. At this point the pointer to the classes are
deleted from the list. One advantage I can see is that any type of
class can be inserted into this list, though it is not being done at
present

[jolest]

Ninan wrote:

I should confess that I am not the inventor of this code. It belongs to
someone who left the job and whose work I have taken over
But rationale is some thing like this. The pointers to classes are
inserted into a list of integers. At a future point in time the
contents of the classes are converted (streamed) to socket messages and
sent over the network. At this point the pointer to the classes are
deleted from the list. One advantage I can see is that any type of
class can be inserted into this list, though it is not being done at
present

As someone pointed out, while you may be currently "getting away with
it", this is not guarenteed to work on all flavors of C++.

If you want conformant code, and all you're trying to do is to have an
array that can contain pointers to any kind of object, why not use void
pointers?

The following typedef may help:
typedef void* VOID_PTR;

... Jolest

PS: Obviously, you'll still need to cast it back to the original type
before deleting it...

[Daniel T.]

In article <11************ **********@v46g 2000cwv.googleg roups.com>,
"Ninan" <ni****@yahoo.c om> wrote:

I am skipping a couple of steps in betweens, like inserting into a list
of ints and extracting from it. But this is the gist of what I am
trying to do

class A {

};

A *a = new A();

int b = (int )a;

delete (A *)b;

Is this equivalent to
delete a?

My code seems to work fine

Others have mentioned the importance of the size of the integral type, I
would think it's also important that the type be unsigned, but I could
be wrong. It just seems that conversions could trip you up otherwise.

Personally, long ago I wrote a system like that. I used the pointer
(this) to uniquely identify objects at runtime. Once you start newing
and deleting objects though, all bets are off. Another object my come
along that has the same id.
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.