when a base class does not have a virtual member, but the
derived class does, the MSVC++ compiler 'slices' the vptr
table from the object, when referencing the derived object
through a pointer to the base class object.

Linux GNU does not do this: there the address/pointer is
the same in both cases.

What does the C++ standard say about this? And if it is
implementation dependent, how do you find out what address
to provide to delete()?

Sample code:

#include <iostream>
using namespace std;

class B
{
public:
    int i;

class D: public B
{
public:
    virtual ~D(){}

void doSomething( B * pb )
{
    cout << hex << pb << endl;

void main()
{
    D * pd = new D;
    cout << hex << pd << endl;
    doSomething( pd );

Results in my system in:

00301E60
00301E64

If you change the Class B to
class B
{
public:
    virtual void fun1(){};
    int i;

The output will be the same.

yhhuang
ICQ:91074870

I'm a C++ newbie, but don't you need to provide a virtual
destructor in your base class anyway so you can use
delete with a base pointer?

The standard doesn't state how this will happen.  You are
specifically NOT supposed to make any assumptions about
how the pointers need to be converted.  If you use legitmate
operations to convert the pointers, this is all taken care
of for you.  Why are you concerning yourself.

Even in GCC, all you have to do is add more than one base
class to the derived class and you guarantee that at least
one of the DERIVED->BASE conversions will need to change
the internal potiner value.

You provide to delete the value that is of the right type.
Note that if you are deleting a derived object whose pointer
has been converted to the base class, the base class NEEDS
to have it's destructor declared virtual for JUST THIS TYPE
OF ISSUE.  It is undefined behavior to do otherwise.

Again, you ought not to be concerned about the literal values
of the pointers, if you obey the language rules for conversion
and delete, things are guaranteed to work.   Trying to make
assumptions on how things work otherwise is going to generate
code that may not work in all instances.

To paraphrase the ARM (annotated reference manual). Any
derived class which contains a destructor should be
derived from a base class with a virtual desctructor IF
the derived object is EVER cast to a base pointer.

The slicing is necessary and EVERY compiler does it. In
many cases the compiler will yield the SAME numeric value
for the two cases so the effect is transparent.

If you add a virtual destructor (or any virtual function
in this case) to your base class you will find this to be
true using VC.

If memory serves me, the GNU compilers place the vtable
pointer at the END of the base area of the first base
class, which would yield the effect you are seeing. I may
be wrong on the details of this last part as it has been
well over six months since I have had to worry about
memory layout using and GNU compiler.

This is all unspecified.

The only pointers you can delete which are not the same in value and
type as what new returned to you are pointers to base class subobjects
(of those new'd objects) which have virtual destructors. Note that
this freedom doesn't apply to the array form of new. Violations of
these rules result in undefined behavior.

This is fine. Per what I described above, it would be undefined for
doSomething() to delete pb in your example, because B does not have a
virtual dtor, and pb points to the B part of a D.

--
Doug Harrison [VC++ MVP]
Eluent Software, LLC
http://www.eluent.com
Tools for Visual C++ and Windows

    True... if he is going to delete with a base pointer.  From the context
of the example, it doesn't appear he is going to.

--
Truth,
James Curran
www.NJTheater.com     (Professional)
www.NovelTheory.com  (Personal)
www.BrandsForLess.Com (Day Job)

    Both MSVC & GNU are slicing the object.  It's just that MSVC is placing
the vtble at the beginning of the object, while GCC is putting it at the
end.

--
Truth,
James Curran
www.NJTheater.com     (Professional)
www.NovelTheory.com  (Personal)
www.BrandsForLess.Com (Day Job)

I inferred it from the OP's question, "How do I know what address to pass to delete?"

I was first inclined to answer:

"Just pass the address you got from the "new" that created it."

Then I read the example where the derived class pointer was passed as a base
class pointer argument to a function.

From that, I thought the implication was:

"I was planning to use a delete statement in a similar base-class-argument function,
not shown in this sample code"

(which I figured was merely written to show the difference in addresses).

Rufus