Discussion :

[Kaluza]

Bonjour.

J'aurai souhaité savoir s'il y avait un "risque" (hormis peut être pour la lisibilité du code) d'utiliser un tableau de char pour y stocker de petits entiers ou cela se manipule exactement comme les short int, et les int ?

Merci

[droggo]

Lai,

Quelle idée saugrenue.

Un tableau de char ne se manipule pas comme comme un int (ou un short int), où as-tu pris cette idée ?

Tu ne gagneras absolument rien, et tu perdras pas mal, alors oublie tout de suite.

[Kaluza]

Oula, il y a peut être eu mauvaise interprétation de ce que j'ai voulu dire (en me relisant c'était en effet peut être pas clair). Ce que je voulais dire était : est-ce qu'un tableau de char se gère exactement de la même façon qu'un tableau de int ?

En fait j'ai vraiment besoin d'économiser de la mémoire et j'ai seulement besoin de pouvoir stocker une valeur entre 0 et 20 dans mon tableau... Du coup si je ne peux utiliser qu'un octet par case, ce serait cool...

[koala01]

Salut,

Si tes valeurs sont comprises entre 0 et 20, tu peux effectivement envisager l'utilisation d'un tableau de unsigned char, pour autant que tu sois certains des valeurs limites!!!!

Cependant, je déconseillerais fortement de le faire à moins d'avoir vraiment de très bonnes raisons de le faire (un manque de mémoire ou d'une quantité pharaonique d'éléments)

Ceci dit, dans certaines conditions, l'utilisation d'un tableau de caractères est le passage obligé, comme par exemple, s'il s'agit de charger en cache le contenu d'un fichier "binaire" (le très mal nommé)

[JolyLoic]

Pour moi :
Un tableau de char stocke des caractères, pas des entiers.
Un tableau d'unsigned char stocke des données 8 bits sur lesquelles on va faire des opérations bit à bit (le fait d'être unsigned évite plein d'erreurs sur ces manipulations).
Un tableau de signed char stocke des petits entiers, sur lesquels on va faire des opérations arithmétiques (le fait d'être signed évite plein d'erreurs sur ces manipulations).

Sachant que par tableau, si la taille est dynamique, j'entends std::vector.

[oodini]

Utilise uint8_t.

[Emmanuel Deloget]

Utilise uint8_t.

(dans stdint.h)

ou std::uint8_t, dans <tr1/cstdint> (ou <cstdint> selon le compilateur et la version du standard supportée).

[JolyLoic]

Utilise uint8_t.

Pourquoi uint8_t ? Comme le cas particulier 0 est dans la plage des nombres qu'il utilise, alors que 128 en est loin, utiliser un type signé me semble préférable...

[oxyde356]

Pourquoi uint8_t ? Comme le cas particulier 0 est dans la plage des nombres qu'il utilise, alors que 128 en est loin, utiliser un type signé me semble préférable...

+1
Il stocke ok, mais il fait peut-être des traitements. Des fois qu'il fasse une boucle de décrémentation jusqu'à 0 s'il utilise des unsigned il risque de faire une boucle infinie, autant éviter ce cas.

[oodini]

Pourquoi uint8_t ?

Parce que c'est sémantiquement plus conforme.
Si on est laxiste sur la sémantique, autant utiliser un char.

[oxyde356]

Parce que c'est sémantiquement plus conforme.
Si on est laxiste sur la sémantique, autant utiliser un char.

Pas si ça peut induire un risque inutile. int8_t est plus conforme que le char et plus sûr que uint8_t dans la plage de valeur [0;20]

[Pop360]

Salut,

Sinon une autre solution serait de déclarer un type qui prend 5bits en mémoire, cela permet d'écrire des chiffres allant de 0 à 31 en prenant moins de place qu'un char (qui utilise 8bits); une structure fait l'affaire :

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
#include <stdio.h>
 
 
struct petite_valeur {
 
unsigned int valeur:5; // entier codé sur 5bits
 
};
 
int main() {
 
struct petite_valeur valeur_test;
 
 
valeur_test.valeur = 0;
 
printf("%u\n", valeur_test.valeur); // Affiche 0
 
valeur_test.valeur = 7;
 
printf("%u\n", valeur_test.valeur); // Affiche 7
 
valeur_test.valeur = 20;
 
printf("%u\n", valeur_test.valeur); // Affiche 20
 
valeur_test.valeur = 31;
 
printf("%u\n", valeur_test.valeur); // Affiche 31
 
valeur_test.valeur = 32;
 
printf("%u\n", valeur_test.valeur); // Affiche 0 car le nombre n'est codé que sur 5bits
 
valeur_test.valeur = 33;
 
printf("%u\n", valeur_test.valeur); // Affiche 1 car le nombre n'est codé que sur 5bits
 
//...
 
return 0;
 
}

C++dialement,

Pop360

[Emmanuel Deloget]

Salut,

Sinon une autre solution serait de déclarer un type qui prend 5bits en mémoire, cela permet d'écrire des chiffres allant de 0 à 31 en prenant moins de place qu'un char (qui utilise 8bits); une structure fait l'affaire :

<snip>

C++dialement,

Pop360

Sauf que... Tu utilises un usigned int comme type de base dans ton champs de bits, et du coup, sizeof(petite_valeur) == sizeof(unsigned int).

De manière générale, il n'est pas possible de créer un type dont la taille est inférieure à sizeof(char) == 1 byte (pas 8 bits ; les bytes en C++ n'ont pas un nombre de bits fixés par la norme).

[oodini]

(pas 8 bits ; les bytes en C++ n'ont pas un nombre de bits fixés par la norme).

Merci. Grâce à toi, j'ai appris qu'un byte n'était pas équivalent à un octet. Et merci à Wikipedia pour les éclaircissements supplémentaires. :-)

[droggo]

Mue,

Ok pour le int8_t, mais s'il y a beaucoup de calculs, ça va ralentir par rapport à l'utilisation d'un int normal, pour cause de désalignement des données en mémoire.
Il faut donc voir si la quantité mémoire économisée justifie cette perte de performances, et il en faut beaucoup pour que ce soit le cas.

[oodini]

Pourrais-tu expliciter ce point, droggo, STP ?

[droggo]

Mai,

Il suffit de récupérer les chartes des processeurs, et d'éplucher tout ça (cycles / instruction, qui varient selon les données, en particulier pour toutes les instructions impliquant des accès mémoire, pour des données non alignées sur la taille native du processeur).

Tu trouveras ça sur le site Intel, en farfouillant un peu (rarement vu un site de grand fabricant aussi mal organisé, à moins qu'il l'aient refait entièrement depuis ma dernière visite ).