La classe vide est elle vide ?

Soyez le premier à donner votre avis sur cette source.

Snippet vu 3 812 fois - Téléchargée 38 fois

Contenu du snippet

la classe vide est elle vide et quelle est sa taille ?
Ceci n'est pas une discussion philosophique sur le vide
On se propose plutôt d'étudier la classe suivante :
class A{};

qu'y a t il à l'intérieur ? quelle est sa taille ?

- Etape 1 : la taille de la classe vide
- Etape 2 : la génération des Ctor et Dtor
- Etape 3 : la génération du Ctor de copie
- Etape 4 : la génération de l'opérateur =

Source / Exemple :


//*******************************************************
//Etape 1 : "la taille de la classe vide"
//*******************************************************
class A
{//vide?
};

void main()
{
	//que répond le compilateur sur la ligne suivante ?
	cout << "sizeof(A)=" << sizeof(A) << endl;
/* la surprise est qu'il répond 1 : pourquoi ?
Pour "respecter le principe d'identité" : les objets sont identifiés par leur adresse mémoire
Soit la ligne de code suivante :*/
//	A a1, a2; //allocation sur la pile de a1 et a2
/* Le compilateur chargé d'organiser les allocations mémoires doit réserver
 la mémoire pour les objets a1 et a2.
 Il réserve sizeof(a1) octets pour a1 à l'adresse &a1 puis décale la pile
de la même quantité pour l'allocation suivante.
 Il réserve alors sizeof(a2) octets pour a2 à l'adresse &a2.
Si sizeof(a1) valait 0 (sous prétexte que la classe est vide de données membres),
 les deux objets a1 et a2 seraient alloués au même endroit !
C'est pour préserver leur identité (matérialisée en C++ par l'adresse mémoire de l'objet)
qu'il retourne un 1 "technique"*/
	return ;
	}

//*******************************************************
/* Etape 2 : "la génération des Ctor et Dtor"
//*******************************************************
Question : pourquoi le code précédent fonctionne t il ?
Plus précisément : quelle méthode appelons nous lors de la ligne suivante ?
A a1;
Réponse : le Ctor par défaut ET le Dtor
l'appel du Ctor se voit
Si vous n'êtes pas convaincus de l'appel du Dtor, donnez en un explicitement
et passez le en private.
class A
{
private:
~A(){}
};
Il est bon de tracer l'exécution des Ctor et Dtor de la classe et l'on fournira les notres :
class A
{
public:
A(){cout << "Ctor" << endl;}
~A(){cout << "Dtor" << endl;}
};
Conclusion : il existe bien un Ctor par défaut et le Dtor dans la classe
Ils ont été générés par le compilateur
La règle veut que si l'on ne définit AUCUN Ctor, le compilateur en génère un
Si le Dtor n'est pas explicitement défini, le compilateur le génère
Après avoir fourni les nôtres, le compilateur ne génère bien sûr plus les siens
  On voit donc que la classe vide n'est pas vide de fonction membres
  et ce n'est pas fini.

//*******************************************************
/* Etape 3 : "la génération du Ctor de copie"
//*******************************************************
Question : pourquoi le code suivant fonctionne t il ?
A a3(a2);
Réponse : Il y a création d'un objet a3 qui est le clone de l'objet a2
La méthode invoquée est le Ctor de copie de la classe A
Elle est générée automatiquement par le compilateur
Pouvez vous déduire son prototype de la ligne d'invocation ?
Le type de retour est absent (Ctor oblige!)
Le type de l'argument est une sorte de A
Nous avons le choix entre 'A', 'A&', 'const A' et 'const A&'
Essayons donc le premier, le plus simple
Que se passe t il ? voyons le détail dans l'exemple suivant :

class A
{
A(A a){}
};

en cherchant à compiler ceci, le compilateur se plaint 
Il nous indique notre erreur, le prototype du Ctor de copie est raté
Soulevons le voile : il s'avère que le Ctor de copie est invoqué à chaque
fois que l'objet doit être ... copié. Quelle surprise !
Si l'on passe un argument par valeur, l'objet est copié et le Ctor de copie est appelé
Ceci revient à s'appeler soi-même ... indéfiniment et le compilo l'interdit.
Merci compilo.
Le bon prototype est le plus puissant : 'const A&'
Ecrivons notre Ctor de copie. C'est simple, il suffit de copier proprement toutes les 
données membres de notre classe. Ici c'est simple : y-en-a-pas
voici notre implémentation
A(const A& a){cout << "Ctor de Copie" << endl;}//trace

Conclusion :
Si nous ne fournissons pas de Ctor de copie, le compilateur génère le sien

  • /
//******************************************************* /* Etape 4 : "la génération de l'opérateur =" //******************************************************* Question : pourquoi le code suivant fonctionne t il ? A a4; a4 = a3; Réponse : le compilateur génère un operateur d'affectation pour toute classe (et struct) Quel est son prototype ? void operator=(const A& a);//le petit A& operator=(const A& a);//le grand qui permet le chaînage a4=a3=a2 Voici notre implémentation (simple car la classe est vide) : A& operator=(const A& a) { cout << "operator=" << endl; return *this;} Conclusion : Si nous ne fournissons pas d'opérateur =, le compilateur génère le sien Il est appelé à chaque fois qu'un objet existant est affecté à un autre Dernière remarque importante : Entraînez vous Attention à ne pas confondre opérateur = et Ctor de copie A a2 = a1; //Ctor de copie car l'objet a2 est en construction (+ initialisation) a2 = a1; //opérateur d'affectation car a2 existe déjà (il a déja été construit)
  • /
//voici enfin l'équivalent de notre classe vide class A { public: A(){} A(const A&){} ~A(){} A& operator=(const A&){return *this;} }; //et un exemple de classe non vide (mais simple) class B { private: int i_; public: B(int i = 0){ i_ = i;} B(const B& b){ i_ = b.i_;} ~B(){} B& operator=(const B& b){ i_ = b.i_; return *this;} }; //pour la classe B, la taille est 4 soit sizeof(int) //le détail des tailles et les considérations d'alignement sont un autre thème //pour un exemple de classe non triviale // voir l'article suivant : Classe Canonique => ni Fuite, ni Trap

A voir également

Ajouter un commentaire Commentaires
Messages postés
237
Date d'inscription
lundi 20 mai 2002
Statut
Membre
Dernière intervention
22 juillet 2011
2
Impressionnant :)
Messages postés
2
Date d'inscription
mardi 22 avril 2003
Statut
Membre
Dernière intervention
22 avril 2003

Vous êtes fous. Tous.
:)
Messages postés
249
Date d'inscription
mardi 16 juillet 2002
Statut
Membre
Dernière intervention
7 août 2003
2
Ha ok mais je croyais que tu me disais ça aussi pour les structs. Mais bon c'était simplement ce que je demandais dans ma petite histoire :)
Messages postés
338
Date d'inscription
jeudi 22 août 2002
Statut
Membre
Dernière intervention
14 juin 2005

waouuwww magnifique :) v étudier ce truc a fond chui sur ke je v apprendre plein de trucs super :)))
Messages postés
949
Date d'inscription
mardi 2 octobre 2001
Statut
Membre
Dernière intervention
8 juillet 2006
1
Je ré-essaye :)
Tu ne peux pas utiliser fichier.write( reinterpret_cast<const char *>( &nom_de_la_classe_ou_de_la_struct ), sizeof( la_classe )) pour stocker une instance de classe dans un fichier par exemple et ensuite faire un read() pour récupérer ton objet.
Afficher les 11 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.