Risque d'utiliser un tableau de char pour stocker de petits entiers ?

Version imprimable

30/08/2011, 20h36
Kaluza

Risque d'utiliser un tableau de char pour stocker de petits entiers ?

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
30/08/2011, 21h10
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. :)
30/08/2011, 21h47
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...
30/08/2011, 22h12
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é)
31/08/2011, 09h10
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.
31/08/2011, 10h25
oodini

Utilise uint8_t.
31/08/2011, 14h35
Emmanuel Deloget

Citation:

Envoyé par oodini

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).
31/08/2011, 14h48
JolyLoic

Citation:

Envoyé par oodini

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...
31/08/2011, 15h08
oxyde356

Citation:

Envoyé par JolyLoic

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.
31/08/2011, 15h56
oodini

Citation:

Envoyé par JolyLoic

Pourquoi uint8_t ?

Parce que c'est sémantiquement plus conforme.
Si on est laxiste sur la sémantique, autant utiliser un char.
31/08/2011, 16h14
oxyde356

Citation:

Envoyé par oodini

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]

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:

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

01/09/2011, 09h58
Emmanuel Deloget

Citation:

Envoyé par 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 :

<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).
01/09/2011, 10h38
oodini

Citation:

Envoyé par Emmanuel Deloget

(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. :-)
01/09/2011, 13h59
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.
01/09/2011, 14h10
oodini

Pourrais-tu expliciter ce point, droggo, STP ?
01/09/2011, 15h52
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 :().