C++ classe abstraite destructeur

Est-il judicieux (et c'est possible) pour créer une classe abstraite en utilisant seulement un destructeur virtuel pur dans la classe parent?

Voici un exemple de

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

class Derived : public AbstractBase {
public:
    Derived() {}
    virtual ~Derived() {}
};

Sinon, comment puis-je créer une classe abstraite si les attributs et les constructeurs des produits dérivés de la classe sont tous les mêmes alors que l'autre méthode sont totalement différentes?

Appelé (vide) de l'interface et oui, il est parfaitement possible. Pour quel usage?
Alors, quelle doit être la valeur de cette classe abstraite? L'introduction d'un particulier de la hiérarchie d'héritage? N'a pas beaucoup de sens pour moi.
Pas un vide de l'interface, comme je l'ai dit. Aussi appelé "marqueur" de l'interface.
Vous avez probablement oublié le virtual mot-clé. Mais mon point est que je ne comprends pas ce que vous souhaitez utiliser cette classe/interface pour. Il semble littéralement inutile. Non pas que je suis un expert sur le C++...
Cette question est plus approprié pour programmers.stackexchange.com

OriginalL'auteur user3758182 | 2014-06-19

abstract-class c++destructor

5

Avoir qu'un pur destructeur virtuel de la classe de base est rarement une bonne pratique, mais il est possible et, dans certains cas, et même souhaitable.

Par exemple, si vous comptez sur la RTTI à envoyer des messages à un sous-objet en tentant un dynamic_cast sur le pointeur vers la classe de base, vous pouvez avoir besoin d'aucune méthode dans la classe de base sauf le destructeur. Dans ce cas, vérifiez le destructeur virtuel public.

Puisque vous n'avez pas d'autres méthodes virtuelles sauf le destructeur, vous devez vous rendre pur afin d'empêcher la création des objets de la classe de base.

Ici, il est essentiel de fournir le corps est vide pour que le destructeur (même si c'est "=0"!)
```
struct AbstractBase {
     virtual ~AbstractBase() = 0;
}

AbstractBase::~AbstractBase() {
}
```
Avoir le corps permet la création de sous-classe d'objets (à condition que le sous-classe définit le destructeur et ne le définit pas comme une pure).

Pouvez-vous écrire un simple exemple de pure destructeur virtuel? Je vais avoir quelques difficultés...
Êtes-vous sûr que la sous-classe doit définir un destructeur ? J'ai pu compiler un exemple dans MSVC avec =0{...code...} et un vide de la classe dérivée. Comme tu le dis, aucun objet ne peut être créé pour la classe de base (virtuelle pure), mais je peux créer un objet de la classe dérivée: Lorsqu'il est détruit, il appelle le code btw {} de la classe de base destructeur.
En d'autres termes, il est possible de créer l'objet de base seulement comme un sous-objet d'un objet de la classe dérivée. N'est-ce pas ce que l'on a naturellement envie? Ok, si vous voulez interdire la création de la sous-classe de l'objet, de définir la sous-classe de " destructeur comme virtuelle pure, trop. Il n'est pas nécessaire de définir un destructeur dans une sous-classe, mais il faut le définir si la sous-classe doit de nettoyage de certaines ressources.

OriginalL'auteur Oleg
13

Une interface en C++ DOIT disposer d'un destructeur virtuel qui est mis en œuvre et ne fait rien. Toutes les autres méthodes dans l'interface ont être définie comme abstraite (par exemple, l'ajout d' = 0 dans la déclaration). Cela permettra d'assurer que vous ne serez pas en mesure de créer une instance de votre classe d'interface, mais vous pouvez le supprimer de votre objet une fois que vous avez attribué votre pointeur d'interface de l'objet parent. Désolé pour la mauvaise formulation, voici un peu de code:
```
class ISampleInterface
{
public:
    virtual ~ISampleInterface() { };
    virtual void Method1() = 0;
    virtual void Method2() = 0;
}

class SampleClass : public ISampleInterface
{
public:
    SampleClass() { };
    void Method1() { };
    void Method2() { };
}

int main()
{
    ISampleInterface *pObject = (ISampleInterface*)new SampleClass();
    delete pObject;
    return 0;
}
```
OriginalL'auteur armanali
2

Cette question me rappelle un Le vieux Chose de Nouveau post:

Un client a demandé des conseils sur la façon d'accomplir quelque chose ... Et je n'étais pas convaincu que c'était une bonne idée, un peu comme demander des conseils sur comment attraper une balle de baseball de vos dents ou de les chercher tout le fromage hors de votre cheeseburger.

Je l'ai expliqué plusieurs des pièges de leur approche ... et je conclu avec la phrase "Cette idée est semée d'embûches, et j'ai peur que mes réponses à vos questions seront interprétés comme une approbation plutôt que réticent à l'assistance."

Vous peut créer une classe de base abstraite avec seulement un virtual destructeur. Je ne suis pas sûr pourquoi vous désirez. Sachant qu'un objet dérive d'un type, dire Foo, devrait-il dire que je sais ce que je peux faire avec cet objet. Dans ce cas, je sais seulement que je pouvais détruire l'objet, ce qui n'est pas utile d'informations.

Mais vous avez raison la plus évidente de l'approche ne compile pas:
```
struct Foo {
    virtual ~Foo() = 0;
};

struct Bar : Foo {
    ~Bar() { }
};

struct Baz : Foo {
    ~Baz() override { } //C++11
};
```
Lorsque j'essaie de compiler ceci, j'obtiens une erreur de lien, car, tout en Bar::~Bar() et Baz::~Baz() sont définis, Foo::~Foo() n'est pas, et le compilateur veut appeler Foo::~Foo() chaque fois qu'un Bar ou un Baz est détruit.

Il y a deux solutions. La première est que virtual fonctions n'ont pas à être virtuelle pure:
```
struct Foo {
    virtual ~Foo() { }
};

struct Bar : Foo {
    ~Bar() { }
};

struct Baz : Foo {
    ~Baz() override { } //C++11
};

struct Quux : Foo { };
```
Mais vous avez spécifiquement demandé pour un pur destructeur virtuel. Et la réponse est certainement bizarre: des fonctions virtuelles pures peuvent être définies par la classe qui déclare virtuelle pure:
```
struct Foo {
    virtual ~Foo() = 0;
};

Foo::~Foo() { }

struct Bar : Foo {
    ~Bar() { }
};

struct Baz : Foo {
    ~Baz() override { } //C++11
};

struct Quux : Foo { };
```
Le fait que vous peut cela ne signifie pas que c'est une bonne idée. Il est très rare que vous souhaitez déclarer une fonction virtuelle pure alors que la définition de la fonction. Il pourrait arriver, mais il sera très rare.

Sinon, comment puis-je créer une classe abstraite si les attributs et les constructeurs des produits dérivés de la classe sont tous les mêmes alors que l'autre méthode sont totalement différentes?

Je pense vraiment ce qui me dérange, c'est que la plupart des conseils de nos jours est d'utiliser des fonctions virtuelles pures pour créer quelque chose comme interfaces Java. Lorsque vous faites cela, vous déclarez les méthodes que les classes dérivées besoin de soutien, mais de laisser partir ces classes libres d'utiliser toutes les données, les membres ont du sens. Vous avez l'intention de déclarer seulement ce que les membres de données de types doit contenir, et de laisser le types gratuit avoir sauvagement différentes méthodes pour les données. Cela semble être une mauvaise idée.

OriginalL'auteur Max Lybbert

Vous devez vous connecter pour publier un commentaire.