Discussion :

[sambia39]

Bonjour
J'aurais besoin de quelque éclaircissement sur certaines informations que je vais énoncer ci-dessous.
j'ai remarqué que deux structures ayant les mêmes données, en strictement pas la même taille et cela me force à les réaligner.
Dans l'exemple plus en bas, la différence de taille est elle dû au fait que sizeof prend en compte l'espace physique de la structure & l'espace inutilisé qui pointe sur les types de la structure ? ou c'est juste autres choses et pourquoi ?

Code C :

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
 
#include <stdio.h>
#include <stdlib.h>
 
// Exemple 1
struct st_ExpA{
 
	   char tA[20];
	   char tB[10];
	   char tC[5];
	   long lA;
	   long lB;	
}A;
// Même structure Exemple 1
struct st_ExpB{
 
       char tA[20];
	   long lA;
	   char tB[10];
	   long lB;	
	   char tC[5];	
}B;
//Forçage d'alignement
struct ts_Alig{
 
	unsigned long pos_X: 16;
	unsigned long pos_Y: 16;
}Al;
 
//Programme principale de teste
int main( void ){
 
	printf( "Size A =\t%d\n", sizeof( A ) );
	printf( "Size B =\t%d\n", sizeof( B ) );
 
	return( 0 );
}

(Après compilation en remarque que la seconde structure de donnée prend plus d'espace mémoire).
Merci d'avance pour vos réponses et à bientôt

[CodeurPlusPlus]

Peut-être le char t[5] est-il aligné sur un nombre pair d'octets s'il n'est pas le dernier du struct ?

[foetus]

En commentant les attributs, tu trouves ta solution

En gros sur une plateforme 32bits, il y a des alignements sur des multiples de 4 octets (32bits == 4 octets)

Pour la structure st_ExpA, tu vas perdre un octet entre lA et lB, pour arriver à 44 octets au lieu de 43.
tA + tB + tC + lA = 39 octets.
Mais le compilateur l'aligne sur 40 octets (10*4)

Pour la structure st_ExpA, c'est plus compliqué
tA + lA = 24 octets (4*6) pas de problèmes

tA + lA + tB = 34 octets, aligné sur 36 (9*4)

tA + lA + tB + lB = 40 octets (4*10) pas de problèmes

tA + lA + tB + lB + tC = 45 octets, aligné sur 48 (12*4)


Et au passage c'est #pragma pack qui permet de faire de l'alignement

[schonai]

Bonjour,
Foetus a tout bon! C'est pour ça qu'il vaut mieux en général classer les membres par taille décroissante dans les structures afin de minimiser se phénomène au milieu de la structure.

[sambia39]

En commentant les attributs, tu trouves ta solution

Bonsoir
Merci et il me semble l'avoir compris , mais ceci dit la question était de savoir si sizeof prenait en compte l'alignement des espaces inutilisés avec le reste des données et il me semble que ça soit le cas, et je suis d'avis sur la déclaration décroissante des types pour un alignement correct.
Et pour un alignement comme ce qui suit , on à pas forcement besoin de #pragma pack ? si

Code C :

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
 
#include <stdio.h>
#include <stdlib.h>
 
// Exemple 1
struct st_ExpA{
	   char: 4;
	   long: 4;
 
	   char tA[3];
	   char tB[1];
	   long lA;
 
}A;
// Même structure Exemple 1
struct st_ExpB{
	   char: 1;
	   long: 1;
 
       char tA[3];
	   long lA;
	   char tB[1];
}B;
 
//Programme principale de teste
int main( void ){
 
	printf( "Size A =\t%d\n", sizeof( A ) );
	printf( "Size B =\t%d\n", sizeof( B ) );
 
	return( 0 );
}

[ternel]

Bonjour,
si je me souviens bien, sizeof retourne la taille en octet de l'objet fourni.
Si c'est un tableau, c'est l'ensemble de ses éléments.
Si c'est une structure, c'est la différence entre le premier et le dernier octet.

Dans mon souvenir, si s est une structure (du type struct S) ayant membre pour dernier membre, on doit avoir sizeof s = sizeof S >= &s.membre +sizeof(s.membre) (car il peut y avoir du padding au bout.)

[sambia39]

Bonjour
Ok. Je pense avoir compris. Les types s'alignent au bord des mots (4 octets) selon les règles d'alignement des variables et les structures toujours en début ou fin de périmètre ce qui fait que sizeof connaît la taille des données tout en prenons en compte la représentation physique de la structure mais également les zone inutilisé ce qui donne pour une structure similaire, des tailles différentes.
Pour essayer de comprendre ce que j'avance, la première structure dans le dernier exemple à une taille de 8 octets parce que les caractères s'alignent sur les 4 premiers octets et le long à la suite. Quant à la deuxième structure elle prend un peu plus d'octets car, elle aligne avant tout 3 octets avec une zone vide d'un octet puis les 4 octets du long et viens ensuite un octet pour le dernier membre avec à la suite 3 octets vide (inutile, en claire c'est du gaspillage pour rien) et la question que je me pose pourquoi c'est octet en plus pour rien est-ce volontaire.

Je vais peut-être dire une connerie mais, y aurait-il pas une option autre que "-wpadded" car ,au lieu de savoir si une structure est alignée ou pas on peut juste demander au compilateur de les réaligner.
à bientôt

[foetus]

La réponse est simple
Le processeur ne travaille qu'avec des morceaux de 4 octets (32 bits) ou 8 octets (64 bits)
C'est plus simple pour lui de commencer un attribut au prochain multiple au lieu qu'il soit à cheval

Exemple: En 32 bits, une structure avec A un tableau de 3 chars (3 octets) et B un int (4 octets)
Cas facile (un truc de ce goût): || A0 : A1 : A2 : Bourrage +1 || < - : - : B : - > ||
Cas pas facile: || A0 : A1 : A2 : < - || - : B : - > : Indéfini ||

Alignement en mémoire