Discussion :

[gl]

donc si je veux avoir un code portable quelque soit le support, il faut que je considère les types avec les tailles décrites ci-dessous ?

Code :

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

1
2
3
4
5
char = 1 octet
short = 2 octets
int = 2 octets
long = 4 octets
long long = 8 octets

Si tu veux faire du code portable, il faut partir du principe que tu n'auras pas mieux que la plage minimale garantie et utiliser le type adéquate sans présumer de sa taille.
Pour du code non portable, se baser sur la taille des types sur l'architecture cible est possible mais tu n'est plus portable.

Sinon, C99 a introduit des types à taille fixe (int8_t, etc.) mais :

• Il faut un compilateur C99.
• Le support de ces types n'est pas obligatoire (si la cible ne dispose pas de type natif 8 bits, int8_t n'existera pas).

non tu ne peux pas du tout présumer de la taille d'un integer (sauf char)

Même pour char, il n'y a pas de certitude.

Par définition sizeof(char) vaut 1. Mais ce n'est pas forcément 1 octet (CHAR_BIT donne la taille d'un char).


Au passage boboss123, la taille n'est pas le seul point à prendre en compte lorsqu'on manipule des entiers et que l'on vise un code portable, il y a notamment :

• L'endianness.
• Le codage des nombres signés (la norme permet complément à 2, complément à 1 et signe+valeur)
• Le type char est-il signé ou non.

[Médinoc]

=> je ne sais pas pourquoi mais pour une certaine valeur, le printf m'affiche "FFFFCED0FFFF" : de quoi ça peut venir (normalement ça ne devrait afficher que des chaines de 8 caractères) ?

Cela ressemble à un problème de nombres signés et d'extension de signe; il faudrait voir ce que ça donne si tu forces les nombres (surtout les champs de la structure) à des types non-signés.

[boboss123]

Cela ressemble à un problème de nombres signés et d'extension de signe; il faudrait voir ce que ça donne si tu forces les nombres (surtout les champs de la structure) à des types non-signés.

C'est bon j'ai trouvé,

Pour remplir mon DWORD_VAL, j'utilisais un pointeur de char => avant sur mon µControlleur 8 bits je n'avais pas de problème car les char n'étaient pas signés et avec le passage au µC 32 bits ils sont devenus signés d'où le problème :'(
=> on en revient au problème de portabilité ....

Il me semble que le mieux serait de n'utiliser que des types définis à l'aide de #define (exemple : #define BYTE unsigned char) et de se faire une petite fonction qu'on utilise lors de la phase de debug qui affiche si l'un des types définis ne correspond pas à ce que l'on attend
=> si l'un des types ne correspond pas à ce qu'on attend, il suffirait alors de modifier le .h de déclaration des types


merci

[matafan]

Pour vérifier la taille des types à la compilation, une astuce bien pratique :

Code :

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

int check_long[(sizeof(long) * CHAR_BIT == 32) - 1];

Qui ne compile que si un long fait 32 bits.

[Médinoc]

Par contre, je ne connais aucun stratagème pour vérifier l'endianness à la compilation.

[boboss123]

Pour ceux que ça intéresse, j'ai fais une petite fonction :

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
void printTypes(void){
	char charTmp;
	signed char scharTmp;
	unsigned char *ptUCharTmp;
	short shortTmp;
	int intTmp;
	long longTmp;
	long long longlongTmp;
 
	printf("\r\n- Fonction printTypes()\r\n");
 
	printf("\t- Taille d'un char : %d bits => correspond à une unité de sizeof\r\n", CHAR_BIT);
 
	printf("\t- Sizeof:\r\n");
 
	// ****************
	printf("\t\tchar: %ld => ", sizeof(char));
		charTmp = 0; charTmp--;
		if (charTmp > 0){
			printf("non-signé\r\n");
		} else {
			printf("signé\r\n");
		}
	printf("\t\tuchar: %ld\r\n", sizeof(unsigned char));
	printf("\t\tschar: %ld\r\n", sizeof(signed char));
 
	// ****************
	printf("\t\tshort: %ld => ", sizeof(short));
		shortTmp = 0; shortTmp--;
		if (shortTmp > 0){
			printf("non-signé\r\n");
		} else {
			printf("signé\r\n");
		}
	printf("\t\tushort: %ld\r\n", sizeof(unsigned short));
	printf("\t\tsshort: %ld\r\n", sizeof(signed short));
 
	// ****************
	printf("\t\tint: %ld => ", sizeof(int));
		intTmp = 0; intTmp--;
		if (intTmp > 0){
			printf("non-signé\r\n");
		} else {
			printf("signé\r\n");
		}
	printf("\t\tuint: %ld\r\n", sizeof(unsigned int));
	printf("\t\tsint: %ld\r\n", sizeof(signed int));
 
	// ****************
	printf("\t\tlong: %ld => ", sizeof(long));
		longTmp = 0; longTmp--;		
		if (longTmp > 0){
			printf("non-signé\r\n");
		} else {
			printf("signé\r\n");
		}
	printf("\t\tulong: %ld\r\n", sizeof(unsigned long));
	printf("\t\tslong: %ld\r\n", sizeof(signed long));
 
	// ****************
	printf("\t\tlonglong: %ld => ", sizeof(long long));
		longlongTmp = 0; longlongTmp--;		
		if (longlongTmp > 0){
			printf("non-signé\r\n");
		} else {
			printf("signé\r\n");
		}
	printf("\t\tulonglong: %ld\r\n", sizeof(unsigned long long));
	printf("\t\tslonglong: %ld\r\n", sizeof(signed long long));
 
 
 
	// ****************
	// type d'encodage
	scharTmp = 1;
	scharTmp = ~scharTmp;
	scharTmp += 1;
 
	printf("\t- Encodage du signe: ");
	if (scharTmp == -1){
		printf("complément A2\r\n"); // 1 => 000000001 = inv => 11111110 = +1 => 11111111
	} else {
		scharTmp = 1;
		scharTmp = ~scharTmp;
 
		if (scharTmp == -1){
			printf("complément A1\r\n"); // 1 => 000000001 = inv => 11111110
		} else {
			printf("signe + valeur\r\n");  // 1 => 000000001 = ajout signe => 100000001
		}
	}
 
 
	// ****************
	// Endianness
	printf("\t- Endianness: ");
	longlongTmp = 1;
	ptUCharTmp = (unsigned char*)&longlongTmp;
	if (*ptUCharTmp != 0u){
		printf("Little endian\r\n");
	} else {
		printf("Big endian\r\n");
	}
 
 
	printf("\r\n");
}

=> en espérant qu'elle soit portable et non buggée ... j'ai quelques doutes sur l'Endianness...