Comment puis-je supprimer manuellement une instance d'une classe?

Exemple:

#include <iostream>
#include <cstring>

class Cheese {
private:
    string brand;
    float cost;
public:
    Cheese(); //Default constructor
    Cheese(string brand, float cost); //Parametrized constructor
    Cheese(const Cheese & rhs); //Copy construtor
    ~Cheese(); //Destructor
    //etc... other useful stuff follows
}

int main() {
    Cheese cheddar("Cabot Clothbound", 8.99);
    Cheese swiss("Jarlsberg", 4.99);

    whack swiss; 
    //fairly certain that "whack" is not a keyword,
    //but I am trying to make a point. Trash this instance!

    Cheese swiss("Gruyère",5.99);
    //re-instantiate swiss

    cout << "\n\n";
    return 0;
}

Comment est "Cabot en toile," Cheddar - Vient de nulle part à proximité de Cheddar
Une variable (instance d'une classe) déclaré sur la pile peut avoir son mémoire à zéro avec memset (ce qui serait utile dans certains cas, je suppose...), mais sa mémoire ne peut pas être libéré jusqu'à la fin de la portée de la fonction vous avez déclaré dans (jusqu'à la fin de votre principal ici). Vous pouvez simplement remplacer votre contenu variable avec le constructeur de copie si vous voulez vraiment rester sur la pile, mais pourquoi ne pas utiliser le tas et les pointeurs dans ce cas, où vous pouvez delete votre instance?
en.wikipedia.org/wiki/Cheddar_cheese
Ce n'est pas comme du champagne. Ce n'est pas un terme protégé. Le nom fait référence à la recette qui est née au Cheddar. Un peu comme les millions de dollars "à l'Américaine" gris écureuils dont les parents et grands-parents ont même jamais entendu parler de l'Amérique laisser seuls ensemble de la patte!
Je sais que - malheureusement - mais l'anglais des trucs de Cheddar est le meilleur. Aussi le champagne est une autre invention anglaise.Raté encore une fois 🙁

OriginalL'auteur kmiklas | 2016-03-24

c++class destructor instance kill

8

Sans connaître les cas d'utilisation ou le problème que vous souhaitez résoudre (veuillez lire sur le XY problème, votre question est un bon exemple de cela) la façon la plus simple est juste de réaffectation:
```
Cheese swiss("Jarlsberg", 4.99);
...
swiss = Cheese("Gruyère",5.99);
```
Qui pourraient vous obliger à mettre en œuvre un opérateur d'affectation, mais à la suite de la règles de trois ou cinq vous devriez faire de toute façon (mais l'opérateur d'affectation n'est pas nécessaire si vous suivez la règle de zéro).

Vous pourrait également utiliser des pointeurs, si vous souhaitez explicitement à détruire l'actuel swiss objet:
```
Cheese* swiss = new Cheese("Jarlsberg", 4.99);
...
delete swiss;
swiss = new Cheese("Gruyère",5.99);
```
Mais des pointeurs est une boîte de pandore que vous devriez éviter, et n'ont pas vraiment besoin de beaucoup en C++ moderne. Mais les pointeurs (ou références) sont nécessaires si vous voulez polymorphisme. Alors vous pourriez avoir un pointeur sur la classe de base de pointage à l'instance réelle, et des choses comme des fonctions virtuelles fonctionnent comme prévu.

Aussi, et en fonction de votre situation dont nous ne savons encore rien sur, vous pouvez bien sûr utiliser le cadrage:
```
Cheese swiss("Jarlsberg", 4.99);
...
{
    Cheese swiss("Gruyère",5.99);
    //In here the swiss cheese is a Gruyère
    ...
}
//Out here the swiss cheese is a Jarlsberg
```
Si l'occultation des noms de variables comme cela fonctionne, c'est une mauvaise habitude que vous devriez éviter que cela ajoute de la confusion pour les lecteurs de code. D'autre part, même lors de l'utilisation des étendues rien ne vous empêche d'utiliser tout (valide) nom de la variable que vous voulez, de sorte que vous pouvez nommer l'extérieur de la portée de l'instance jarlsberg l'intérieur de la portée de l'instance gruyere, le gruyere objet serait alors détruite à la fin de la portée tout comme n'importe quel autre imbriquée-portée variable serait détruite, et "disparaître".

Le nom de l'observation est une mauvaise idée, oui, mais vous pouvez le rendre plus clair que le général technique de l'utilisation des appareils pour le contrôle de la portée est de loin le de trois montré techniques.
Des domaines distincts serait la meilleure, mais je tiens à promouvoir séquentielle étendues, pas imbriquée étendues: { Cheese swiss(1); } ... { Cheese swiss(2); }
Les suggestions utiles, je vous remercie. Suis-je donc en conclure que cette fonctionnalité n'existe pas dans la langue, comme indiqué dans l'OP? Qui est: whack swiss;

OriginalL'auteur Some programmer dude
4

On peut utiliser de portée pour vous permettre de définir une autre instance d'une classe.
```
Cheese swiss("Toe", 3.14)

{
    Cheese swiss("Ear", 15.9);
}
```
En règle générale déclarés localement les instances de détruire eux-mêmes quand ils passent hors de portée.

Si vous avez vraiment d'alimentation de la nécessité de détruire le fromage, alors vous avez besoin d'allouer dynamiquement de la place.
```
  Cheese *swiss = new Cheese("toe", 3);

   //do something with swiss.

   delete swiss;    //throw it away.

   swiss = new Cheese("Ear", 7);

   //do something with swiss.

   delete swiss;    //throw it away.
```
De mémoire allouée dynamiquement doit toujours être supprimé manuellement.

"en règle générale" Lire: absolument toujours, sans exception. C'est ce qui se passe hors de portée des moyens.
"la mémoire allouée Dynamiquement doit toujours être supprimés manuellement" Qui était vrai il y a vingt ans, mais maintenant que vous devriez être en utilisant des pointeurs intelligents il s'agit essentiellement d' jamais true dans le code de bonne.
J'adore votre pseudo. Je suis d'accord avec vous. Le problème est que l'op est nouveau ou qu'il ne serait pas à poser une question de ce genre. La réponse s'efforce de point de lui deux choses qu'il doit savoir au sujet de. la réponse est déjà suffisamment complexe sans l'ajout de la notion de pointeurs intelligents, ou de la gestion des exceptions nécessaires pour traiter correctement avec ce code.
Si l'OP est nouveau, alors c'est encore plus important de ne pas misteach eux, comme ils ne savent pas la différence. En outre, les pointeurs intelligents sont les facile approche que nous devrions commencer avec; laisser les rubriques avancées comme le manuel de gestion de la mémoire lorsque l'OP a un peu plus d'expérience.
Me semble que vous devriez répondre à la question.

OriginalL'auteur EvilTeach
2

Rares sont les cas où vous auriez besoin pour ce faire. Mais un que vous pourriez rencontrer, c'est lors de la création d'un type abstrait de données.

Par exemple, si vous réalisez une variante de type, vous aurez probablement souhaitez configurer une aligné type de données, puis manuellement placement new et delete.
```
typename std::aligned_union<0, FirstType, RestTypes...>::type m_buffer;
```
Vivifier:
```
new (&m_buffer) AssignType(forward<T>(x));
```
Pour effacer:
```
(HeldType*)(&m_buffer)->~HeldType();
```
Cependant, comme mentionné dans l'un des nombreux autres postes. Si vous êtes à la programmation normalement, vous n'avez pas besoin de vous soucier manuellement appeler dtors. Si c'est sur la pile, puis il est nettoyé pour vous. Si c'est sur le tas puis delete prendra soin de cela pour vous. Le seul moment où vous voulez faire, ce est où vous êtes manuellement la prise de contrôle sur la durée de vie de l'objet, et la raison principale pourquoi vous voulez le faire est lorsque vous êtes à la mise en œuvre d'un type abstrait de données.

Bonne réponse, sauf pour la "pile"/"en tas", gubbins
Est-il une nomenclature qui préféré?

OriginalL'auteur OmnipotentEntity

Le Côté Sombre de C++ possède une technique pour effectuer exactement ce que tu décris dans le post original. Je ne sais pas pourquoi vous voulez faire cela, peut-être que la mise en œuvre d'un opérateur d'affectation semble fastidieux. Peut-être que vous avez un désir morbide de faire quelque chose de contre nature de votre programme. Je peux vous assurer qu'aucune personne "normale" envisagez d'utiliser le code que je vous dévoile ci-dessous, au moins pas quand les autres sont en train de regarder. Alors, pourquoi suis-je mettre cela ici?

Parce que je suis sadique.

J'en appelle à la puissance de la Communauté Wiki pour me protège contre l'attaque!

#include <iostream>
#include <string>
#include <new>
template <typename T, typename ...As>
inline void Reconstruct(T &ojt, const As&... ctor_args) {
//Explicitly call the destructor, to destroy the object
//without doing anything to its memory allocation.
ojt.~T();
//Use Placement new to call a constructor.
//Instead of allocating memory somewhere for a new object,
//this specifies where the new object will be constructed --
//given here as the location of the object's previous
//incarnation.
//Also pass any arguments to the constructor.  I forced
//these arguments to be const references in order to
//avoid extra copying, so "move" construction won't work
//and steps might need to be taken to accommodate other,
//more unusual constructors.
new(&ojt) T(ctor_args...);
}
class Cheese {
std::string brand;
float       cost;
public:
Cheese() : cost(0) {}
Cheese(std::string brand, float cost) : brand(brand), cost(cost) {}
Cheese(const Cheese & rhs) = default;
~Cheese() = default;
friend std::ostream& operator << (std::ostream& os, const Cheese& chz) {
return os << "[brand:\"" << chz.brand << "\" cost:" << chz.cost << ']';
}
};
int main() {
Cheese cheese, fromage;
std::cout << "cheese = " << cheese << '\n';
Reconstruct(cheese, "Cabot Clothbound", 8.99f);
std::cout << "cheese = " << cheese << '\n';
Reconstruct(fromage, cheese);
std::cout << "fromage = " << fromage << '\n';
Reconstruct(cheese, "Jarlsberg", 4.99f);
std::cout << "cheese = " << cheese << '\n';
}

OriginalL'auteur

0

Si pour quelque raison vous ne pouvez pas utiliser l'opérateur d'affectation, vous pouvez utiliser un optional.
```
std::experimental::optional<Cheese> swiss(std::experimental::in_place, "Jarlsberg", 4.99);
swiss = std::experimental::nullopt; //Calls Cheese::~Cheese internally
//re-instantiate swiss
swiss.emplace("Gruyère",5.99);
```
Aussi longtemps que vous ne stockez pas l'option, vous pouvez sans doute compter sur le compilateur optimisant les extra interne bool.

OriginalL'auteur sbabbi

Vous devez vous connecter pour publier un commentaire.