class MaClasse
{
    // ... 
    ~MaClasse();
};
 

#include <iostream>

class Test
{
public:
    ~Test() { std::cout << "Destruction\n"; }
};

int main()
{
    Test t;
    t.~Test(); // appelle explicite du destructeur
} // ici, le compilateur appelle à nouveau le destructeur

void userCode()
{
    Fred a;
    Fred b;
    // ...
}

void userCode()
{
    Fred a[10];
    // ...
}
 

void someCode()
{
    {
        File f;
        // ... [Ici, le fichier est encore ouvert] ...
    }
    // ^— Ici, le destructeur de f est appelé automatiquement!
    // ^— Ici, le destructeur de f est appelé automatiquement!
    
    // ... [Le code ici s'exécutera après que f soit fermé]  ...
}
 

class File {
    public:
      void close();
      ~File();
       // ...
    private:
      int fileHandle_;    //  fileHandle_ >= 0 seulement si le fichier est ouvert
    };
    
    File::~File()
    {
      close();
    }
    
    void File::close()
    {
      if (fileHandle_ >= 0) {
         // ... [Utiliser les appels systèmes qui conviennent pour fermer le fichier] ...
        fileHandle_ = -1;
      }
}
 

Fred* p = new Fred();
 

 delete p; // p->~Fred() est appelé automatiquement
 

class Member {
    public:
      ~Member();
       // ...
};
    
class Fred {
    public:
      ~Fred();
       // ...
    private:
      Member x_;
      Member y_;
      Member z_;
};
    
Fred::~Fred()
{
    // Le compilateur appelle automatiquement  z_.~Member()
    // Le compilateur appelle automatiquement  y_.~Member()
    // Le compilateur appelle automatiquement  x_.~Member()
}

 

class Member {
   public:
      ~Member();
       // ...
};
    
class Base {
   public:
      virtual ~Base();      // Un destructeur virtuel 
       // ...
};
    
class Derived : public Base {
   public:
      ~Derived();
       // ...
   private:
      Member x_;
};
    
Derived::~Derived()
{
    // Le compilateur appelle automatiquement x_.~Member()
    // Le compilateur appelle automatiquement Base::~Base()
}
 

#include <iostream>

// classe de base A destinée à être dérivée
class A
{
public:
    A() { std::cout << "Constructeur de A.\n"; }
    ~A() { std::cout << "Destructeur de A.\n"; }

    virtual void PrintName() { std::cout << "Classe A.\n"; }
};

// B hérite de A
class B : public A
{
public:
    B() { std::cout << "Constructeur de B.\n"; }
    ~B() { std::cout << "Destructeur de B.\n"; }

    virtual void PrintName() { std::cout << "Classe B.\n"; }
};

int main()
{
    // utilisation polymorphique de B
    A * a = new B; // construction de A et B
    a->PrintName(); // affiche "Classe B"
    delete a; // destruction de A mais pas de B !
}

class A
{
public:
    A() { std::cout << "Constructeur de A.\n"; }
    virtual ~A() { std::cout << "Destructeur de A.\n"; }

    virtual void PrintName() { std::cout << "Classe A.\n"; }
};