struct foo { virtual ~foo() {} };

int main()
{
  delete new foo[2];
}

*** glibc detected *** ./x: munmap_chunk(): invalid pointer: 0x09ac900c ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x73e42)[0x8a9e42]
/lib/i386-linux-gnu/libc.so.6(+0x74525)[0x8aa525]
/usr/lib/i386-linux-gnu/libstdc++.so.6(_ZdlPv+0x1f)[0x54c51f]
./x[0x8048708]
./x[0x80486b6]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0x84f4d3]
./x[0x80484d1]

#include <stdio.h>

struct A {
  void check_fn() { printf("check:"); fn(); }
  virtual void fn() { printf("A.fn\n"); }
  virtual ~A() { printf("~A\n"); check_fn(); }
};

struct B : A {
  void fn() { printf("B.fn\n"); }
  ~B() { printf("~B\n"); }
};

int main(int,char**) {
  B b;
  b.check_fn();
  return 0;
}

check:B.fn
~B
~A
check:A.fn

struct Thread { // TThread, CWinThread...
  virtual void Run()=0;
  virtual ~Thread() { Join(); }
  void Join() { ... }
  void Start() { ... }
};
struct MsgThread : Thread {
  void Run() { 
    for(;;) dispatch_message();
  }
  virtual void dispatch_message() {...}
};
...
void test() {
  MsgThread t;
  t.Start();
  sleep(100);
  // тут неявный вызов ~MyThread, он в свою очередь запустит ~Thread который начнёт ожидать завершения потока.
  // и почти сразу упадёт Run т.к. указателя на dispatch_message уже нет. ~Thread поменял vft.
}

#include <iostream>

struct B
{
    virtual void f() { std::cout << "B::f\n"; }
    void g() { f(); }
};

struct D1 : B
{
    D1()
    {
        B *b = this;
        b->f(); // calls D1::f
        g();    // calls D1::f
    }
    virtual void f() { std::cout << "D1::f\n"; }
};

struct D2 : D1
{
    virtual void f() { std::cout << "D2::f\n"; }
};

int main()
{
    D2 d;
}

#include <iostream>

M>struct B
M>{
M>    virtual void f() { std::cout << "B::f\n"; }
M>    void g() { f(); }
M>};

M>struct D1 : B
M>{
M>    D1()
M>    {
M>        B *b = this;
        b->>f(); // calls D1::f
M>        g();    // calls D1::f
M>    }
M>    virtual void f() { std::cout << "D1::f\n"; }
M>};

M>struct D2 : D1
M>{
M>    virtual void f() { std::cout << "D2::f\n"; }
M>};

M>int main()
M>{
M>    D2 d;
M>}

class CLASS {
 ctor {
  this->vft=CLASS.vft;
  ctor_body();
 }
 dtor {
  this->vft=CLASS.vft;
  dtor_body();
 }
}

struct base
{
  virtual void f() {}
  void g() { f(); } // здесь будет заведомо виртуальный вызов (хотя, компилятор может проинлайнить g()...)
  base() { f(); g(); } // по крайней мере единожды будет виртуальный вызов f() - из g()
};

struct foo
{
  std::string name;

  void curricumvita()
  {
    born();
    lived();
    dead();
    rip();
  }

  void born()  { name = "foo"; }
  void lived() { std::cout << "hello, " << name << std::endl; }
  void dead()  { delete this; }
  void rip()   { std::cout << "R.I.P. " << name << std::endl; } // бабах!
};

int main() { new foo(); }

Не всплывёт его бедное тело, грабли на дне я поставил умело.