Re: this newsroup

"Leigh Johnston" <leigh@i42.co.uk> wrote...


I guess you refer to the "pointer is used as the operand of a
dynamic_cast" part, which is implicitly done in the f(n-1) call above.
That is a technical violation, indeed, though inconsequential in the
simple example at hand.

That said, below is a modified version which covers the general case
where B can have extra data members and/or be derived through
multiple inheritance. Note that the two asserts never fire, which
confirms that the example satisfies the original requirement that the
pointer doesn't change.

Liviu


//--------------------------------

#include <cstdlib>
#include <cassert>
#include <algorithm>
using std::max;
#include <iostream>
using std::cout;
using std::endl;

struct A
{
 static int count, alive;
 A() { count++; alive++; }
 ~A() { alive--; }

 virtual void f(int n);
};

struct B : public A
{
 static int count, alive;
 B() { count++; alive++; }
 ~B() { alive--; }

 virtual void f(int n);
};

int A::count, A::alive, B::count, B::alive;

void A::f(int n)
{
 cout << "A::f, object " << count - B::count << ", this = " << (const
void *)this << endl;
 if(n)
 {
   this->~A();
/*
   note: right here 'this' points to an unitialized object,
         which is legal for essentially the same reasons
         why 'delete this' is allowed in member functions
*/
   A *that = (n % 3) ? new(this) A : new(this) B;
   assert(this == that);
   that->f(n - 1);
 }
}

void B::f(int n)
{
 cout << "B::f, object " << count<< ", this = " << (const void *)this
<< endl;
 if(n)
 {
   this->~B();
   A *that = (n % 3) ? new(this) B : new(this) A;
   assert(this == that);
   that->f(n - 1);
 }
}

int main()
{
 void *p = malloc(max(sizeof(A), sizeof(B)));
 A *a = new(p) A;

 a->f(10);

 a->~A();
 free(p);
}

//--------------------------------