Discussion :

[camboui]

Y'a-t-il des documents sur le sujet ?
Exemple:

Code :

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

1
2
3
4
5
6
7
struct vide {};
 
struct MaStruct
{
int i_;
vide v_;
};

Le sizeof(vide)==1, et sizeof(MaStruct)==5 voir 8 ou plus si on exige un alignement de mémoire.
Ce n'est pas optimal, dans bien des cas on pourrait faire ce qui suit sans trop de problèmes pratiques (enfin, je crois...).

Code :

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

1
2
3
4
struct MaStruct: vide
{
int i_;
};

L'avantage est que sizeof(MaStruct)==4 cette fois.
Qu'en pensez-vous ?

[Goten]

La plus part des compilos n'augmenteront pas la taille de la structure si tu dérives d'une classe vide. (ça a un nom : empty base class optimization)
Sa sert a pas mal de chose (les allocateurs sont basé sur ce principe).

[Arzar]

Y'a-t-il des documents sur le sujet ?

L'article fondateur :
http://www.cantrip.org/emptyopt.html

[3DArchi]

Salut,
En tant que membre, une instance ne peut avoir de taille nulle. Ne serait-ce que pour distinguer deux instances consécutives :

Code :

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

1
2
3
4
5
6
7
8
9
10
struct vide{};
struct conteneur
{
vide v1;
vide v2;
vide tab_v[10];
};
conteneur c;
assert(&(c.v1)!=&(c.v2));
assert(&tab_v[0]!=&tab_v[1]); // etc..

En revanche, le compilateur optimise pour l'héritage. C'est un cas où on utilise un héritage privé à la place d'une composition.

[camboui]

Donc c'est bien cela, les membres vides d'une structure prennent toujours de la place. Dériver la structure de ces classes vides est donc bien la solution pour éviter de perdre de la place.
Dommage que les structures de la stl ne fassent pas ainsi, je pense surtout à std::string dont un des membres est l'allocateur standard std::allocator par défaut. Et std::allocator est vide. Je suppose qu'à l'époque on n'y avait pas penser...

[camboui]

Bon, et maintenant qu'en est-il pour un passage en paramètre ?

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
struct vide
{
 template<class T>
 void do(T const &) {}
};
 
struct encore_vide
{
 template<class T>
 void do(T const & t)
 {
  std::cout << t << std::endl;
 }
};
 
template<class T, class V>
void foo(T t, V v)<-- de la mémoire sur le stack pour v ?
{
 ...
 v.do(t);
 ...
}
 
int main()
{
 foo(33, vide());
 foo("trente-trois", encore_vide());
}

Est-ce que lors des appels de foo() dans main() il va y avoir de l'espace réservé sur le stack pour "vide" et "encore_vide" ?

[Klaim]

Donc c'est bien cela, les membres vides d'une structure prennent toujours de la place. Dériver la structure de ces classes vides est donc bien la solution pour éviter de perdre de la place.

Oui parceque les membres ont besoin d'avoir des adresses mémoire séparées (donc avec au moins 1 byte de décalage) mais dans le cas de l'héritage l'abstraction fait qu'on peut utiliser la même adresse pour la classe de base vide et la classe enfant.
En fait dés qu'on comprends les cas où on a besoin d'une adresse mémoire séparée, on déduit plus facilement où on peut perdre de la mémoire même avec des membres vides.