C++ problème destructor avec boost :: scoped_ptr

Question

J'ai une question sur le code suivant:

#include <iostream> 
#include <boost/scoped_ptr.hpp> 

class Interface 
{ 
}; 

class A : public Interface 
{ 
    public: 
     A() { std::cout << "A()" << std::endl; } 
     virtual ~A() { std::cout << "~A()" << std::endl; } 
}; 


Interface* get_a() 
{ 
    A* a = new A; 
    return a; 
} 

int main() 
{ 
    { 
     std::cout << "1" << std::endl; 
     boost::scoped_ptr<Interface> x(get_a()); 
     std::cout << "2" << std::endl; 
    } 
    std::cout << "3" << std::endl; 
} 

Il crée la sortie suivante:

1 
A() 
2 
3 

Comme vous pouvez le voir, il ne remet pas le destructeur de A. La seule façon dont je vois que le destructeur de A est appelé est d'ajouter un destructeur pour la classe Interface comme ceci:

virtual ~Interface() { } 

Mais je veux vraiment éviter toute implémentation dans ma classe Interface et virtual ~Interface() = 0; ne fonctionne pas (produit des erreurs de l'éditeur de liens se plaignant d'une implémentation non existante de ~Interface(). Donc ma question est: Qu'est-ce que je dois changer pour que le destructeur soit appelé, mais (si possible) quitte l'interface en tant qu'interface (seulement des méthodes abstraites).

Answer 1

Vous devez définir une destructor virtuelle dans la classe de base, sinon vous aurez pas le comportement polymorphique.

Et plus important encore, vous obtenez un comportement indéfini; §5.3.5/3:

Si le type statique de l'opérande est différent de son type dynamique, le type statique doit être une classe de base de type dynamique de l'opérande et le type statique doit avoir un destructeur virtuel ou le comportement est indéfini.

_{Emphasis mine.}

---

Je dirais le meilleur est celui-ci:

class Interface 
{ 
public: 
    virtual ~Interface(void) = 0; 
}; 

inline Interface::~Interface(void) {} 

Le compilateur peut facilement inline ce, contrairement à une solution où la mise en œuvre réside dans un fichier source. (En parlant de cela, cette solution ne vous oblige même pas à en avoir une.) Elle laisse également la classe pure virtuelle.

Answer 2

Vous devez déclarer le destructeur virtual si vous souhaitez supprimer des objets de classe dérivée via un pointeur vers votre type d'interface de classe de base, et que ce destructeur doit avoir une implémentation.

Vous pouvez toujours le déclarer pur virtuel, cependant:

class Interface 
{ 
public: 
    virtual ~Interface() = 0; 
}; 

inline Interface::~Interface() { } 

Answer 3

Vous devez définir une version virtuelle pure du destructeur d'interface, mais vous devez également définir le corps du destructeur. C'est une sorte de cas bizarre en C++ où même si la fonction est virtuelle, elle doit être définie car après l'appel du destructeur A, le destructeur d'instance sera également appelé.

Ainsi, la bonne réponse est:

virtual ~Interface() = 0; 

Et plus tard, dans un fichier cpp:

Interface::~Interface() {}