LA CLASSE VIDE EST ELLE VIDE ?

//*******************************************************
//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