Portée des variables membres privées - C ++

Question

Je commence tout juste avec C ++ et j'ai quelques problèmes pour comprendre le fonctionnement de la portée des variables de membre privées dans une classe. Veuillez voir le code ci-dessous

class Foo{
    private:
        std::vector<int> container;
    public:
        // other methods
};

int main(int argc, char* argv[])
{
    Foo* foo = new Foo;
    // other method calls to which foo is passed
    delete foo;
    return 0;
}

Dans le code ci-dessus, variable " conteneur " est une variable membre privée. J'invoque & Quot; Foo & Quot; exemple et en le passant à plusieurs autres méthodes et classes. Voici mes doutes

1. Quelle sera la portée de la variable & "conteneur &"; Cette variable existera-t-elle jusqu'à ce que je supprime l'instance foo?
2. Dois-je créer le " conteneur " comme un pointeur sur un vecteur?

Merci pour l'aide

Answer 1

1. Oui, la durée de vie du membre du conteneur durera tant que l'objet qui le contient existera, c'est-à-dire jusqu'à ce que vous appeliez delete le pointeur qui le pointe (foo dans votre Cas).
2. Non, il n'y a aucune raison de le faire. Pour en faire un pointeur, vous devez créer un objet dynamique de vector<int> dont vous auriez besoin pour gérer la durée de vie (y compris l'appelant delete sur le pointeur du conteneur). C'est inutile ici. En supposant que vous souhaitiez que le conteneur dure aussi longtemps que l’objet Foo, vous pouvez le contenir directement sans le faire avec un pointeur.

Passer le pointeur <=> ne fera que passer le pointeur. L'objet sur lequel il pointe ne sera pas , mais seul le pointeur le pointant le cas échéant. Si vous connaissez Java, cela vous aidera si je vous dis que passer le pointeur revient à transmettre une référence à un objet en Java, par exemple:

Foo f = new Foo();
// just passes the reference (pointer in C++) to doIt. 
// the actual object is not copied
doIt(f);

Answer 2

J'invoque & "Foo &"; instance

En fait, vous créez une instance de la classe Foo .

Plus précisément, vous allouez un bloc de mémoire hors du tas via new () . Ce bloc de mémoire est suffisamment volumineux pour contenir Foo :: container et toute autre classe de surcharge que Foo nécessite.

(Dans cet exemple, il n'y en a aucun. Avec d'autres classes, il peut y avoir des attributs supplémentaires ou peut-être une table de pointeur virtuel.)

Naturellement, new () appelle le constructeur (peut-être par défaut?) Foo :: Foo () , qui initialise à son tour Foo :: container via le constructeur std :: vector .

Quelle sera la portée de la variable & "conteneur &"?

conteneur est un attribut [composant] de l'instance toto . Il existe tant que l'instance foo existe.

En termes de portée, nous pouvons parler de Foo :: container . Mais vous ne pouvez pas accéder à Foo :: constainer sans une instance de la classe Foo . (P. Ex. L'objet toto .) Foo :: constainer n'existe pas sans instance de classe Foo .

(Il existe des variables de classe qui fonctionnent quelque peu différemment, dans lesquelles une valeur est partagée par toutes les instances. Mais ce n'est pas le cas ici.)

Cette portée est IRRELEVANT pour le contrôle de vos membres public / protected / private / friend.

Par exemple, dans certains Foo :: myPublicMethod () , vous pouvez faire référence à Foo :: container . Bien que vous puissiez également renoncer à la portée explicite dans cette situation et simplement vous y référer en tant que conteneur .

Attention, étant privé, vous ne pouvez pas accéder à Foo :: container en dehors des méthodes de la classe Foo .

Cette variable existera-t-elle jusqu'à ce que je supprime l'instance foo?

Oui.

Dois-je créer le & "conteneur &"; comme un pointeur sur le vecteur?

Non. Vous pouvez le faire, mais ce n’est certainement pas nécessaire.

De manière générale, je déconseille aux membres d'instance de classe d'être des pointeurs associés à new dans le constructeur et à delete dans le destructeur. C'est inefficace et gênant. (Le constructeur de copie par défaut peut copier la valeur du pointeur, le destructeur peut ensuite supprimer deux fois la même valeur.)

En fonction de vos besoins, vous pouvez envisager:

int main(int argc, char* argv[])
{
  Foo foo;
  // other method calls to which foo is passed
  return 0;
}

toto serait hors de portée après renvoyer 0; et serait automatiquement supprimé. De plus, toto serait alloué en dehors de la pile plutôt que du tas.

Vous trouverez peut-être une copie utilisée du Manuel de référence du C ++ annoté utile . Il est vieux mais son rapport signal sur bruit est élevé.