Petite question de memoire

Salut,

Par simple curiosite, je me demandais comment le compilateur defini l'espace memoire necessaire a un objet.

Par exemple:

Code:

---

1 2 3 4 5 6 7 8

class Vecteur { private: double m_x; double m_y; double m_z; ... }

---

Puisqu'un double prend 8 bytes et que j'en ai 3, je pensais que la taile d'un objet Vecteur serait de 24 bytes.

En faisant:

Code:

---

sizeof(Vecteur)

---

J'obtiens 32!!! D'ou provient le 8 bytes de plus? Il sert a quoi?

CaptnB

attention : 1 byte = 1 octet = 8 bits

Moi ça fait bien 24 avec :

Code:

---

1 2 3 4 5 6 7

class test { private: double d1; double d2; double d3; };

---

PS : gcc 3.3.6

Ceci provient du pointeur this de la classe.

Une classe vide fait 4 octets.

Code:

---

1 2 3 4 5 6 7 8

class Vecteur { private: double m_x; double m_y; double m_z; ... }

---

Et qu'est ce qui se cache derrière les ... ?

Bon... mon exemple devait pas etre bon :)

La classe pour laquelle j'ai teste a bel et bien trois membres de type double mais elle a aussi quelques methodes dont j'ai pas ecrit les details (des surcharges d'operateurs pour la plupart, question de simplifier les calculs vectoriels). Dans tout les cas, mes instances font 32 octets et pas 24...

Voici la classe:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

class CVector : public CObject { // Friend functions friend CVector operator*(double mult, CVector vec); // Multiply scalar by a vector   private: // Member variables double m_sta; // Staion (x coordinate) double m_bl; // Butt line (y coordinate) double m_wl; // Water line (z coordinate)   public: // Default constructor / destructor CVector(); virtual ~CVector();   // Overloaded operators and copy construtor CVector(const CVector& copy); CVector operator=(const CVector& aff); CVector operator-(); // Invert vector CVector operator/(const double div); // Divide vector by a scalar CVector operator*(const double mult); // Multiply vector by a scalar CVector operator*(const CVector vec); // Cross product CVector operator+(const CVector vec); // Sum CVector operator-(const CVector vec); // Difference double operator%(const CVector vec); // Dot product (% has same precedence than * and /, don't confuse with modulo) double operator^(const CVector vec); // Angle between the vectors   // Get / Set functions double GetBl() const; double GetSta() const; double GetWl() const;   double GetNorm() const;   void SetBl(const double bl); void SetSta(const double sta); void SetWl(const double wl);   void Set(const double sta, const double bl, const double wl); void Set(const CPt* pt1, const CPt* pt2); // CVector from pt1 to pt2   // Other void Unit(); // Transform the vector into a unit vector   CString WriteVector(); };

---

CaptnB

Citation:

---

Envoyé par Caine

Ceci provient du pointeur this de la classe.

Une classe vide fait 4 octets.

---

8O houla houla, this n'est pas mémorisé dans une instance de classe, this contient l'adresse de l'instance courante.

S'il arrive qu'il y ai 4 octets supplémentaires utilisés par instance c'est pour mémoriser l'adresse du vecteur de opérations virtuelles qui est partagé par toutes les instances d'une meme classe. Une classe sans opération virtuelle (hérité ou non) n'a pas besoin de ce vecteur ... ni de mémoriser son adresse.

Humm.....

4 octets pour le pointeur this...

Donc je presume que si ma classe a 8 octets de trop, il y en a 4 pour le pointeur sur le CVector et 4 pour le pointeur sur le CObject (classe de base).

C'est ca???


CaptnB

Je dit peut être une idiotie, mais le pointeur this ne permet pas d' acceder à une classe mére...

A la lumiere de vos explications, j'ai fait d'autres tests. J'ai une classe virtuelle pure qui n'a qu'un int et un CString comme membre. Donc, je devrais avoir 8 octets pour les donnees. En incluant le destructeur, j'ai 10 fonctions membres qui sont virtuelles, donc 40 octets. Je serais suppose obtenir 40 + 8 mais la, j'obtiens juste 12....le mystere persiste!

CaptnB

P.S. Ca m'empeche pas de fonctionner mais, comme je l'ai dit dans mon premier post, j'suis assez curieux de savoir

La taille d'une classe dépend de beaucoup de choses.

- La taille des données membres bien sûr.
- L'alignement mémoire (par défaut l'alignement est généralement à 4 octets).
- La v-table pour les classes comportant des fonctions virtuelles (un seul pointeur -- vers la v-table (puisqu'elle est commune à toutes les instances de la classe)).

D'autant plus qu'il me semble que la norme n'impose rien là-dessus, ça peut varier selon les compilos (à vérifier).

Sur une machine 32 bits l'alignement est de 4 octets meme pour des doubles qui sont mémorisés sur 8 octets.

Les compilateurs cherchent à minimiser la taille des données, y compris en gérant les coupures liées aux héritages :

Code:

---

1 2 3 4 5 6 7 8 9 10

class C1 { public: // pas important ici char c1; };   class C2 : public C1 { public: // pas important ici char c2; };

---

sizeof(C1) == 1 et sizeof(C2) == 2, c.a.d. le début de C2 n'est pas aligné sur 4 octets, mais lors des allocations le début de C1 le sera

Comme je l'ai dis ainsi que loulou24, le vecteur des virtual est une donnée globale partagée dont seule l'adresse est mémorisée dans les instances, bref le nombre d'opérations virtuelles change la taille du vecteur, pas la taille des instances (ouf !). Le but de ce vecteur est de permettre l'appel rapide en temps constant d'une opération virtuelle.

Supposons les defs C++ suivantes :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class C1 { public: // pas important virtual void a(); virtual void b(); };   class C2 : public C1 { public: // pas important virtual void a(); virtual void c(); };

---

le compilo génère quelque chose comme

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void * vt_C1[] = { (void *) &C1::a, (void *) &C1::b };   void * vt_C2[] = { (void *) &C2::a, (void *) &C1::b, // non redéfini dans C2 (void *) &C2::c };

---

Dans chaque instance reelle de C1 (ie par un C2 ou autre sous classe) les 4 premiers octets contiennent l'adresse de vt_C1
Dans chaque instance reelle de C2 (ie pas une sous classe) les 4 premiers octets contiennent l'adresse de vt_C2

Soit x est une instance de C1 ou C2 ou autre classe qui hérite de C1.
Le code genere pour x->a() est alors simplement quelque chose comme

Code:

---

((void(*)()) (*((void ***) x))[0])();

---

Le code genere pour x->b() est alors simplement quelque chose comme

Code:

---

((void(*)()) (*((void ***) x))[1])();

---

etc ... meme si 1000 classes héritent de C1

Les code si dessus sont donnés comme exemple, je ne dis pas que c'est exactement ce que font les compilateurs. De meme lorsque de dis que les 4 premiers octets d'une instance contiennent l'adresse du vecteur des virtuels cela peut etre les 4 octets qui précèdent l'adresse au sens this etc ...

tu peut soit parametrer ton environnement par exemple sous Visual C++ tu peut régler l'alignement mémoire à un 1 Byte, mais tu peut aussi utiliser les bitfields du C : (je crois pas que ça fonctionne sur les classes, que sur les struct à confirmer)

Code:

---

1 2 3 4 5 6 7

struct Bitfield { unsigned int BoolSur1Bit :1; int EntierSur7Bit :7; float FlottantSur8Bits :8; }

---

si tu fias un sizeof() tu auras 2

Citation:

---

Envoyé par CaptnB

Je serais suppose obtenir 40 + 8 mais la, j'obtiens juste 12....le mystere persiste!

---

Non : la VMT est référencée par un UNIQUE pointeur, qui pointe donc sur une table construite soit à la compilation, soit à l'initialisation du programme (dans le segment de démarrage du programme, je ne sais plus s'il porte un nom particulier en C++). En effet, toutes les instances d'une même classe possèdent la même VMT !!

En gros, si tous tes attributs sont statiques, tu n'as pas d'attributs "réels", et la taille de ta classe est "nulle" (souvent, un octet quand même pour éviter les effets de bord).
Si toutes tes méthodes sont non-virtuelles, pas de pointeur de VMT.

En fonction de ta classe, tu vas donc avoir 0 ou 4 octets en plus suivant la présence de la VMT, et en fonction de l'alignement, tu peux avoir entre zéro et (Na-1) octets par attribut de "perte" (alignement Na à 1, 2, 4, 8 et même 16 octets sur les machines modernes).

Calcule les tailles de ces classes, par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

class StaticNoVMT { static char Field1 ; static int Field2 ; void Method ( int Param1 ) ; } ;   class StaticWithVMT { static char Field1 ; static int Field2 ; virtual void Method ( int Param1 ) ; } ;   class ThisNoVMT { char Field1 ; int Field2 ; void Method ( int Param1 ) ; } ;   class ThisWithVMT { char Field1 ; int Field2 ; virtual void Method ( int Param1 ) ; } ;   void StaticNoVMT::Method ( int Param1 ) { Param1++; } void StaticWithVMT::Method ( int Param1 ) { Param1++; } void ThisNoVMT::Method ( int Param1 ) { Param1++; } void ThisWithVMT::Method ( int Param1 ) { Param1++; }

---

(Je sais, c'est crade de déclarer comme ça, c'est juste pour l'exemple !!!).

J'obtiens comme résultats :

Code:

---

1 2 3 4 5 6 7 8 9

Alignement 1 octet : Sizeof(char)= 1 bytes Sizeof(int)= 4 bytes Sizeof(void*)= 4 bytes ---------------- Sizeof(StaticNoVMT)= 1 bytes Sizeof(StaticWithVMT)= 4 bytes Sizeof(ThisNoVMT)= 5 bytes Sizeof(ThisWithVMT)= 9 bytes

---

Code:

---

1 2 3 4 5 6 7 8 9

Alignement 4 octets : Sizeof(char)= 1 bytes Sizeof(int)= 4 bytes Sizeof(void*)= 4 bytes ---------------- Sizeof(StaticNoVMT)= 1 bytes Sizeof(StaticWithVMT)= 4 bytes Sizeof(ThisNoVMT)= 8 bytes Sizeof(ThisWithVMT)= 12 bytes

---

Taille théorique de la classe : 5 octets. Tu remarqueras qu'il n'y a qu'un seul résultat "sizeof" de 5 octets, sur 8 calculs effectués... :twisted: