Discussion :

[ludovic.barrillie]

Bonjour à tous,

je travaille actuellement sous vs2005 et je constate des tailles de classe
un peu bizares. J'ai une classe qui contient une seule donnée menbre de type char et une vingtaine de méthodes et operateurs (rien de static). Lorsque je fais un sizeof de cette classe (ou d'une instance de cette classe), l'operateur me retourne un nombre d'octets (20) largement supérieur à ce que j'attends (1 octets voir 4 suivant l'alignement mémoire), puisque une seule donnée membre de type char. Est-ce que quelqu'un peut me donnée un explication ?

Merci

[screetch]

peux tu montrer la declaration de ta classe ?

[ludovic.barrillie]

Voici ma class:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
class s8
{
	private:
 
	protected:
		virtual void check (const type::c::s8);
 
		type::c::s8 _value;
 
	public:
		s8 (const type::c::s8 = 0);
		s8 (const s8 &);
		~s8 (void);
 
		type::c::s8 value (void) const;
		virtual void value (const type::c::s8);
		virtual void value (const s8 &);
 
		s8 & operator = (const type::c::s8);
		s8 & operator = (const s8 &);
 
		operator type::c::s8 (void);
 
		bool operator == (const type::c::s8);
		bool operator != (const type::c::s8);
		bool operator >  (const type::c::s8);
		bool operator >= (const type::c::s8);
		bool operator <  (const type::c::s8);
		bool operator <= (const type::c::s8);
 
		bool operator == (const s8 &);
		bool operator != (const s8 &);
		bool operator >  (const s8 &);
		bool operator >= (const s8 &);
		bool operator <  (const s8 &);
		bool operator <= (const s8 &);
 
		s8 & operator += (const type::c::s8);
		s8 & operator -= (const type::c::s8);
		s8 & operator *= (const type::c::s8);
		s8 & operator /= (const type::c::s8);
 
		s8 & operator += (const s8 &);
		s8 & operator -= (const s8 &);
		s8 & operator *= (const s8 &);
		s8 & operator /= (const s8 &);
 
		s8 operator + (void);
		s8 operator - (void);
 
		s8 & operator ++ (void);
		s8 operator ++ (int); 
		s8 & operator -- (void);
		s8 operator -- (int); 
 
		bool operator [] (const type::c::u32);
 
		s8 & operator >>= (const type::c::u32);
		s8 & operator <<= (const type::c::u32);
		s8 & operator ~ (void);
 
		s8 & operator &= (const type::c::s8);
		s8 & operator |= (const type::c::s8);
		s8 & operator ^= (const type::c::s8);
 
		s8 & operator &= (const s8 &);
		s8 & operator |= (const s8 &);
		s8 & operator ^= (const s8 &);
 
		bool operator ! (void);
		operator bool (void);
 
		friend s8 operator + (const s8 &, const s8 &);
		friend s8 operator - (const s8 &, const s8 &);
		friend s8 operator * (const s8 &, const s8 &);
		friend s8 operator / (const s8 &, const s8 &);
 
		friend s8 operator + (const type::c::s8, const s8 &);
		friend s8 operator - (const type::c::s8, const s8 &);
		friend s8 operator * (const type::c::s8, const s8 &);
		friend s8 operator / (const type::c::s8, const s8 &);
 
		friend s8 operator + (const s8 &, const type::c::s8);
		friend s8 operator - (const s8 &, const type::c::s8);
		friend s8 operator * (const s8 &, const type::c::s8);
		friend s8 operator / (const s8 &, const type::c::s8);
 
};

[screetch]

si je definis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
namespace type
{
	namespace c
	{
		typedef signed char s8;
		typedef unsigned int u32;
	}
}

le sizeof me renvoie 8.

c'est parce que tu as des methodes virtuelles qui changent la taille de la classe; sans methode virtuelle, tu tombes a 1.

[ludovic.barrillie]

OK merci, mais je n'est pas compris pourquoi les méthodes virtuelles change la taille d'un classe. Est-ce une spécificité du compilateur microsoft ?

[coyotte507]

+1

[Médinoc]

La présence de méthode virtuelle ajoute au moins un pointeur dans la classe, ce qui la fait passer au minimum de 1 à 8 octets pour raisons d'alignement (en 32 bits. En 64bits, ça peut être 12 ou 16 octets minimum).

Par contre, 20, ça m'étonne grandement. Le résultat de screech me parait plus raisonnable...

[screetch]

c'est du a l'implementation interne des methodes virtuelles; tous les compilateurs ou presque rajoute un pointeur au debut de la classe, pointant sur un tableau contenant la liste des methodes virtuelles

en gros, pour cette classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
class A
{
  char a;
  A() { printf("plop\n"); }
  virtual ~A() {}
};

le compilo va generer ce code la :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
// la table des methodes virtuelles
function* A_methodes_virtuelles[] = { &A::~A };

class A
{
  function* __methodes_virtuelles[];
  char a;

  A() { __methodes_virtuelles = A_methodes_virtuelles; printf("plop\n"); }
}

donc en gros, pour chaque instance, le compilateur se reserve 4 octets au debut pour stocker un pointeur la table des methodes virtuelles, ce qui permettra au runtime plus tard

d'ou les 4 octets de plus

a peu pres tous les compilateurs utilisent cela. En cas d'heritage multiple tu peux meme avoir 2, voire meme 3 pointeurs vers des tables de methodes virtuelle, ajoutant 8 ou 12 octets

quand a la taille finale, lorsque tu rajoutes 4 octets, c'est completement dependant des implementations il me semble. il peut dire sizeof(machin) = 5 ou 8, selon l'alignement et ce qu'il veut generer comme code

[ludovic.barrillie]

OK merci pour l'explication. Pour les 20 octets : ma classe à été dérivé plusieurs fois avec plusieurs surcharges des méthodes virtuelles.

[nicroman]

En fait, c'est plus compliqué que ça...

La vtable d'un objet n'est juste pas un simple pointeur sur une liste de fonctions. Elle contient aussi l'offset sur les données, et tout un tas d'autres trucs qui permettent, par exemple, l'héritage virtuel...

Qu'elle fasse 20 octets ne m'étonne qu'à moitié.

[screetch]

moi ca m'etonnerait carrement. ce que tu stockes reste toujours un pointeur, je crois.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <cstdio>
 
class A
{
public:
    A() {}
    virtual ~A() {}
};
 
class B
{
public:
    B() {}
    virtual ~B() {}
};
 
class C : public A, public B
{
public:
    C() {}
    virtual ~C() {}
};
 
int main(int argc, char *argv[])
{
    printf("sizeof C = %d\n", sizeof C);
    return 0;
}

renvoie 8, soit la taille de 2 _pointeurs sur_ vtable. ajoute des champs ou tu voudras, la taille supplémentaire de C restera sans doute 8.

tout ce que tu avances dans ton post peut etre calculé statiquement en fonction du graphe d'heritage (c'est pour cela que static_cast et dynamic_cast veulent le graphe d'heritage dispo) ou alors on peut le stocker dans la vtable de la classe. rien ne force a stocker plus qu'un pointeur par vtable, le reste va dans la vtable, soit 4 octets par vtable. et il y a une vtable par heritage, pas besoin de plus.