class Base  // abstract class
{
public:
     virtual ~Base();
     void Destroy() { delete this; }

Ury.

class Base  // abstract class
{
protected:
  virtual ~Base();
public:
  void Destroy() { delete this; }

--
Francis Glassborow
Check out the ACCU Spring Conference 2002
4 Days, 4 tracks, 4+ languages, World class speakers
For details see: http://www.accu.org/events/public/accu0204.htm

--
Francis Glassborow
Check out the ACCU Spring Conference 2002
4 Days, 4 tracks, 4+ languages, World class speakers
For details see: http://www.accu.org/events/public/accu0204.htm

Just a quick thought.
The best way to do a compile-time enforcement is to prohibit
working with objects directly, and use some kind of smart pointers,
that will accept/work only with objects with dynamic storage
duration.

If a runtime enforcement would be acceptable and it was acceptable
to prohibit derived classes to overload operator new, there is a simple
and obvious solution (below).
It's somewhat fragile to my sense, but it works.

However, I suspect that there couldn't be a C++ standard conforming
compile time enforcement, just because there is explicitly defined
"stack space" in C++ standard (as opposed to free store).
(I hardly believe we could use "stack unwinding" for these purposes.)

So the OP's question is about differentiating objects with automatic
or static storage duration and objects with dynamic storage duration
at compile time.

AFAIK, the only relevant difference is the way objects with
dynamic storage duration get created/destroyed  (3.7.3/1),
but I don't see how one can exploit it at compile time.

So I would be interested in an answer as well,
because I couldn't think of one.

A runtime enforcement helper sample:

   #include <cassert>
   #include <cstddef>
   struct rt_heapalloc_check
   {
     virtual ~rt_heapalloc_check() {}
     void* operator new(std::size_t sz) { ++heap_check; return ::operator new(sz); }
     void operator delete(void* p) { ::operator delete(p); }
   protected:
     rt_heapalloc_check() { assert(--heap_check==0); }
   private:
     static int heap_check;
   };
   int rt_heapalloc_check::heap_check = 0;

   struct foo : rt_heapalloc_check {};

   int main()
   {
     //B b; //at runtime this will fail an assertion
     B* b= new B; //works fine
     return 0;
   }

Sincerely,
Ruslan Abdikeev