Pourquoi un booléen a-t-il 1 octet et non 1 bit de taille?

En C ++,

• Pourquoi un booléen a-t-il 1 octet et non 1 bit de taille?
• Pourquoi n'y a-t-il pas de types comme des entiers 4 bits ou 2 bits?

Je manque les choses ci-dessus lors de l'écriture d'un émulateur pour un processeur

Parce que le CPU ne peut pas adresser quoi que ce soit de plus petit qu'un octet.

De Wikipedia :

Historiquement, un octet était le nombre de bits utilisés pour coder un seul caractère de texte dans un ordinateur et c'est pour cette raison l'élément adressable de base dans de nombreuses architectures informatiques.

L'octet est donc l' unité adressable de base , en dessous de laquelle l'architecture informatique ne peut pas adresser. Et comme il n'existe pas (probablement) d'ordinateurs prenant en charge l'octet de 4 bits, vous n'avez pas de 4 bits, bool etc.

Cependant, si vous pouvez concevoir une telle architecture qui peut adresser 4 bits comme unité adressable de base, alors vous aurez alors une booltaille de 4 bits, sur cet ordinateur uniquement!

La réponse la plus simple est; c'est parce que le CPU adresse la mémoire en octets et non en bits, et les opérations au niveau du bit sont très lentes.

Cependant, il est possible d'utiliser l'allocation de taille en bits en C ++. Il existe une spécialisation std :: vector pour les vecteurs binaires, ainsi que des structures prenant des entrées de taille binaire.

À l'époque où je devais aller à l'école à pied dans une tempête de neige déchaînée, en montée dans les deux sens, et que le déjeuner était n'importe quel animal que nous pouvions traquer dans les bois derrière l'école et tuer à mains nues, les ordinateurs avaient beaucoup moins de mémoire disponible que aujourd'hui. Le premier ordinateur que j'ai jamais utilisé avait 6K de RAM. Pas 6 mégaoctets, pas 6 gigaoctets, 6 kilo-octets. Dans cet environnement, il était très logique de regrouper autant de booléens que possible dans un int, et nous utiliserions donc régulièrement des opérations pour les supprimer et les insérer.

Aujourd'hui, quand les gens se moqueront de vous pour n'avoir que 1 Go de RAM, et que le seul endroit où vous pourriez trouver un disque dur avec moins de 200 Go est dans un magasin d'antiquités, cela ne vaut tout simplement pas la peine d'emballer des bits.

Vous pouvez utiliser des champs de bits pour obtenir des entiers de taille inférieure.

struct X
{
    int   val:4;   // 4 bit int.
};

Bien qu'il soit généralement utilisé pour mapper les structures aux modèles de bits attendus par le matériel:

struct SomThing   // 1 byte value (on a system where 8 bits is a byte
{
    int   p1:4;   // 4 bit field
    int   p2:3;   // 3 bit field
    int   p3:1;   // 1 bit
};

Vous pourriez avoir des booléens 1 bit et des entiers 4 et 2 bits. Mais cela ferait un ensemble d'instructions étrange sans gain de performance, car c'est une façon non naturelle de regarder l'architecture. Il est en fait logique de «gaspiller» une meilleure partie d'un octet plutôt que d'essayer de récupérer ces données inutilisées.

La seule application qui dérange pour emballer plusieurs booléens dans un seul octet, d'après mon expérience, est Sql Server.

Parce qu'un octet est la plus petite unité adressable de la langue.

Mais vous pouvez faire en sorte que bool prenne 1 bit par exemple si vous en avez un tas, par exemple. dans une structure, comme ceci:

struct A
{
  bool a:1, b:1, c:1, d:1, e:1;
};

boolpeut être un octet - la plus petite taille adressable du processeur, ou peut être plus grande. Il n'est pas inhabituel d'avoir boolla taille de intpour des raisons de performance. Si à des fins spécifiques (par exemple la simulation matérielle) vous avez besoin d'un type avec N bits, vous pouvez trouver une bibliothèque pour cela (par exemple, la bibliothèque GBL a une BitSet<N>classe). Si vous êtes préoccupé par la taille de bool(vous avez probablement un gros conteneur,), vous pouvez emballer des bits vous-même, ou utiliser std::vector<bool>qui le fera pour vous (soyez prudent avec ce dernier, car il ne répond pas aux exigences du conteneur).

Pensez à la façon dont vous implémenteriez cela au niveau de votre émulateur ...

bool a[10] = {false};

bool &rbool = a[3];
bool *pbool = a + 3;

assert(pbool == &rbool);
rbool = true;
assert(*pbool);
*pbool = false;
assert(!rbool);

Parce qu'en général, le CPU alloue de la mémoire avec 1 octet comme unité de base, bien que certains CPU comme MIPS utilisent un mot de 4 octets.

Cependant vectortraite boold'une manière spéciale, avec vector<bool>un bit pour chaque booléen est attribué.

L'octet est la plus petite unité de stockage de données numériques d'un ordinateur. Dans un ordinateur, la RAM a des millions d'octets et n'importe lequel d'entre eux a une adresse. S'il avait une adresse pour chaque bit, un ordinateur pourrait gérer 8 fois moins de RAM que ce qu'il peut.

Plus d'informations: Wikipedia

Même lorsque la taille minimale possible est de 1 octet, vous pouvez avoir 8 bits d'informations booléennes sur 1 octet:

http://en.wikipedia.org/wiki/Bit_array

Le langage Julia a BitArray par exemple, et j'ai lu sur les implémentations C ++.