Nombre de bits dans un type de données

J'ai deux tâches pour une mission, on renvoie le nombre de bits dans le type int sur n'importe quelle machine. J'ai pensé que je voudrais écrire ma fonction comme ceci:

int CountIntBitsF() {
    int x = sizeof(int) / 8;
    return x;
}

Ne fait que regarder à droite?

La deuxième partie consiste à retourner le nombre de bits de tout type de données, avec une macro, la macro peut être pris à partir de limites.h. J'ai regardé les limites.h sur ma machine, et aussi http://www.opengroup.org/onlinepubs/007908799/xsh/limits.h.html, mais je ne pense pas vraiment à comprendre comment une de celles-ci retourne le nombre de bits dans tout type de données. Toutes les pensées? Merci.

Question connexe: c - le Nombre de bits type de base de données.

OriginalL'auteur Crystal | 2010-01-19

c sizeof

8

C'est *, pas /.

Comme pour la deuxième partie, voir les "Limites Numériques".

OriginalL'auteur Ignacio Vazquez-Abrams
15

L'unité fondamentale de stockage est un char. Il n'est pas toujours 8 bits de large. CHAR_BIT est défini dans les limites.h et a le nombre de bits dans un char.

OriginalL'auteur Justin Smith
3

Si vous souhaitez que le nombre de bits utilisés pour stocker un int en mémoire, utilisez la réponse de Justin, sizeof(int)*CHAR_BIT. Si vous voulez connaître le nombre de bits utilisés dans la valeur, de l'utilisation slebetman de réponse.

Bien que pour obtenir les bits dans un INT, vous devriez probablement utiliser INT_MAX plutôt que UINT_MAX. Je ne me souviens pas si C99 assure de fait que int et unsigned int sont de la même largeur, ou simplement qu'ils sont de la même taille de stockage. Je soupçonne seulement celle-ci, puisque dans 6.2.6.2 nous avons "si il y a des M valeur des bits dans le type signé et N pour un type non signé, alors M <= N", pas "M = N ou M = N-1".

Dans la pratique, les types intégraux ne pas avoir de remplissage des bits de la mise en application que j'ai utilisé, de sorte que vous plus de chance d'obtenir la même réponse pour tous, +/- 1 pour le bit de signe.

Une autre citation de C99 projet (6.2.5.6): Pour chaque entier signé types, il existe un correspondant (mais différentes) type entier non signé (désigné par le mot-clé unsigned) qui utilise la même quantité de stockage (y compris le signe de l'information) et a les mêmes exigences alignement.
Merci. Et note "de la même quantité de stockage", il ne dit pas "le même nombre de non-padding bits".
Pourquoi avons-nous besoin de connaître la différence entre un int en mémoire vs les bits utilisés dans la valeur. Est les bits utilisés dans la valeur la plus importante si vous faisiez une sorte de matériel de programmation où vous avez besoin de savoir le nombre de bits utilisés pour représenter certaines valeurs de registre ou quelque chose le long de ces lignes?
Oui, il y a de nombreuses raisons importantes pour des soins sur le bitwidth d'un int. Pour une chose, il détermine comment grand une valeur peut être stockée (c'est à dire, un document signé de 16 bits int pouvez stocker -32768..32767 tout en un entier non signé 16 bits int pouvez stocker 0..65535). Il est également important si vous avez besoin de sérialiser vos données, c'est à dire pour l'enregistrement dans un fichier ou la transmission à travers le réseau.

OriginalL'auteur Steve Jessop
3

Dans limits.h, UINT_MAX est la valeur maximale pour un objet de type unsigned int. Ce qui signifie que c'est un int avec tous les bits mis à 1. Donc, en comptant le nombre de bits dans un int:
```
#include <limits.h>

int intBits () {
    int x = INT_MAX;
    int count = 2; /* start from 1 + 1 because we assume
                    * that sign uses a single bit, which
                    * is a fairly reasonable assumption
                    */

    /* Keep shifting bits to the right until none is left.
     * We use divide instead of >> here since I personally
     * know some compilers which does not shift in zero as
     * the topmost bit
     */
    while (x = x/2) count++;

    return count;
}
```
Ces compilateurs sont la violation de la norme, fwiw.
vous pensez peut-être concernant le passage des connecté valeurs. Pour les types non signés, le déplacement est bien défini.
Il faut rappeler que le code source est transformé en langage machine par des compilateurs, plutôt que par les documents de spécification.
techniquement ce n'est pas une extension de la norme, c'est juste une violation, et le compilateur dans ce mode n'est donc pas un compilateur C, c'est un compilateur d'une autre langue très voisine de C. dans le cas Contraire, Java est une "extension" de la norme C, en ajoutant et en supprimant les règles de C jusqu'à ce que vous vous retrouvez avec Java ;-). Une extension de la norme C est quand vous prenez quelque chose qui ne serait pas légal C, et de définir ce qu'il fait dans votre mise en œuvre. Il n'affecte pas l'effet juridique C.
int et unsigned int ont le même nombre de bits". Je ne trouve pas que dans la norme, savez-vous où il est? Quelles règles dois-je casser si dans mon de la mise en œuvre sizeof(unsigned int) == 4, UINT_MAX == 0xFFFFFFFF, sizeof(int) == 4, INT_MAX == 0x3FFFFFFF, et l'int a un peu de rembourrage pour aucune bonne raison que je peux penser à d'autres que lulz?

OriginalL'auteur slebetman

Avec g++ -O2 cette fonction évalue à une ligne constante:

#include <climits>
#include <stddef.h>
#include <stdint.h>
#include <cstdio>

template <typename T>
size_t num_bits()
{
    return sizeof (T) * (CHAR_BIT);
}

int main()
{
    printf("uint8_t : %d\n", num_bits<uint8_t>());
    printf("size_t : %d\n", num_bits<size_t>());
    printf("long long : %d\n", num_bits<long long>());
    printf("void* : %d\n", num_bits<void*>());
    printf("bool : %d\n", num_bits<bool>());
    printf("float : %d\n", num_bits<float>());
    printf("double : %d\n", num_bits<double>());
    printf("long double : %d\n", num_bits<long double>());

    return 0;
}

sorties:

uint8_t : 8
size_t : 32
long long : 64
void* : 32
bool : 8
float : 32
double : 64
long double : 96

Généré X86 32 bits assember:

---SNIP---

movl    $32, 8(%esp)      <--- const $32
movl    $.LC1, 4(%esp)
movl    $1, (%esp)
call    __printf_chk
movl    $64, 8(%esp)      <--- const $64
movl    $.LC2, 4(%esp)
movl    $1, (%esp)
call    __printf_chk

---SNIP---

OriginalL'auteur Wojciech Migda

1

Êtes-vous sûr que vous voulez le nombre de bits, pas le nombre d'octets? En C, pour un type donné T, vous pouvez trouver le nombre d'octets qu'il faut à l'aide de la sizeof de l'opérateur. Le nombre de bits dans un octet est CHAR_BIT, qui est généralement de 8, mais peut être différent.

Donc, étant donné un type T, le nombre de bits dans un objet de type T est:
```
#include <limits.h>
size_t nbits = sizeof(T) * CHAR_BIT
```
Noter que, sauf pour unsigned char type, toutes les combinaisons possibles de nbits bits ci-dessus ne représentent pas une valeur valide de type T.

Pour la deuxième partie, notez que vous pouvez appliquer sizeof opérateur à un objet de type. En d'autres termes, étant donné un type T et un objet x de ce type:
```
T x;
```
Vous pouvez trouver la taille de T par sizeof(T), et la taille de x par sizeof x. Les parenthèses sont facultatives si sizeof est utilisé pour un objet.

Compte tenu de l'information ci-dessus, vous devriez être en mesure de répondre à votre deuxième question. Demander à nouveau si vous avez encore des questions.

OriginalL'auteur Alok Singhal

Vous devez vous connecter pour publier un commentaire.