#include <cstdlib>
#include <iostream>

using namespace std;

class c1 {
  public:
    c1() {
      cout<<"ctor c1"<<endl;
    }
    /*vitual*/ ~c1() {
      cout<<"dtor c1"<<endl;
    }
};

class c2 : public c1 {
  public:
    c2() {
      cout<<"ctor c2"<<endl;
    }   
    ~c2() {
      cout<<"dtor c2"<<endl;
    }
};

int main(int argc, char *argv[]) {
  {
    c2 test;
  }
  system("PAUSE");
  return EXIT_SUCCESS;
}

class base1
{
public:
 ~base1() { cout << "base1::dtor" << endl; }
};

class derived1: public base1
{
public:
 ~derived1() { cout << "derived1::dtor" << endl; }
};

class base2
{
public:
 virtual ~base2() { cout << "base2::dtor" << endl; }
};

class derived2: public base2
{
public:
 virtual ~derived2() { cout << "derived2::dtor" << endl; }
};

int main(int, char**)
{
 base1 *pb1 = new derived1(); 
 base2 *pb2 = new derived2();

 delete pb1; // -> "base1::dtor", potentieller ressource leak
 delete pb2; // -> "derived2::dtor \n base::dtor", alles sauber

 return 0;
}

class a
{
public:
  ~a() { cout << "a::destructor" << endl; };
};

class b : public a
{
public:
  b() : m_Data(new char[1024]) { cout << "Allocation memory" << endl };
  ~b() { delete [] m_Data; cout << "Deleting mem in ~b" << endl; };

char* m_Data;
};

int main()
{
  a* ptr = new b; // speicher für 1024 chars wird reserviert
  delete ptr;     // und nicht wieder freigegeben
}

Hätte jetzt a einen virtuellen destruktor würde der überschrieben b::~b aufgerufen werden, so wird a::~a aufgerufen.