Longue de type 64 bits linux

Questions très simples, les gars, mais peut-être que je suis juste oublier quelque chose.
En 64 bits, linux, un long est 8bytes correct?
Si c'est le cas, et je veux définir le 64 bits, je peux faire ce qui suit:

unsigned long num = 1<<63;

Chaque fois que je compile cela, cependant, il me donne une erreur en disant que je suis de gauche déplacement de plus de la largeur.
Aussi, si je voulais prendre le premier 32bits de type long (sans l'extension du signe), je peux faire:

num = num&0xFFFFFFFF;

ou ce sujet:

num = (int)(num);

Merci.

Essayez: unsigned long num = 1UL << 63;
Pourquoi ne pas les afficher que comme une réponse avec l'entier de la promotion des trucs ?
Dépend du compilateur utilisé. De nombreux vieux compilateurs est par défaut à 32 bits longs, même si en cours d'exécution sur un ordinateur 64 bits. Confirmer que sizeof num est 8 avant d'essayer quelque chose de plus.
Après avoir répondu aux mêmes questions plusieurs fois et plus encore, il commence à se faire vieux. Donc je ne peux pas me faire plus d ' 1 ligne de réponse...
double possible de attention: décalage à gauche count >= largeur de type

OriginalL'auteur de1337ed | 2012-04-06

bit-manipulation c linux

3

En 64 bits linux, un long est 8bytes correct?

Pas besoin d'être. Dépend du compilateur que sur l'OS sous-jacent. Vérifier cela pour une belle discussion.
Ce qui décide de la sizeof un entier?

Chaque fois que je compile cela, cependant, il me donne une erreur en disant que je suis
gauche déplacement de plus de la largeur

Tout le monde y ai déjà répondu. Utilisation 1UL

Aussi, si je voulais prendre le premier 32bits d'un long type (sans
l'extension du signe), je peux faire:
```
num = num&0xFFFFFFFF;
or what about:

num = (int)(num);
```
num = num&0xFFFFFFFF. Cela vous donnera la baisse de 32 bits. Mais notez que si long est à seulement 4 octets sur votre système, alors vous obtenez la nombre entier. Venir à l'extension du signe de la partie, si vous avez utilisé un long et pas unsigned long alors vous ne pouvez pas faire disparaître le signe étendu bits. Par exemple, -1 est représenté comme tous ceux, à droite de l'0e peu. Comment allez-vous éviter de ceux-ci par masquage?

num = (int)(num) vous donnera la baisse de 32 bits, mais le compilateur peut par le biais d'une Exception de Dépassement d'avertissement si num ne rentre pas dans un int

Acceptez que C n'impose pas de long être 64bits sur 64bits de la machine. Toutefois linux implicitement impose. Il suffit de prendre un coup d'oeil à tous les pointeurs passés par unsigned long et de décalages de mémoire passé à travers signed long (par exemple, appels). Ainsi, tant que le code source de linux n'a pas changer radicalement, je voudrais répondre à oui à la question : "En 64 bits linux, un long est 8bytes, correct ?"

OriginalL'auteur Pavan Manjunath
4

En fait, si vous voulez un peu précis de la longueur (en octets) pour votre entiers, en supposant un C99 conforme compilateur, #include <stdint.h> et l'utilisation des types comme int64_t, int32_t etc. Une pratique de type est intptr_t, un type entier, avec le même nombre de bits que void* pointeur (si on peut appeler ça une machine "mot")

Un C99 conforme compilateur n'a pas besoin de fournir de largeur fixe de types, par exemple int64_t. Seulement deux-compléter les implémentations qui fournissent de 8, 16, 32 et 64-bit integer types sans rembourrage bits sont pour fournir à largeur fixe entier typedefs dans stdint.h.

OriginalL'auteur Basile Starynkevitch
1

Pour la portabilité, vous pouvez utiliser:

limites.h
```
#define LNG_BIT   (sizeof(long) * CHAR_BIT)

unsigned long num = 1UL << (LNG_BIT - 1);
```
Pour obtenir "faible int", quelque chose comme?:
```
#define INT_BIT   (sizeof(int) * CHAR_BIT)

if (LNG_BIT > INT_BIT)
    return num & (~0UL >> INT_BIT);
else
    return num;
```
ou
```
    num &= ~(~0U << INT_BIT);
```
Ou, utiliser un masque, etc. Dépend en grande pourquoi, pour quoi, etc. vous voulez l'int bits.

Également remarquer les options fournies par les compilateurs; I. e. si vous utilisez gcc:
- i386 et x86-64 Options
- Sous-Modèle-Options
^{-m32

-m64

-mx32}
_{Générer du code pour un 32 bits ou 64 bits de l'environnement.

* L'-m32 option définit int, long, et les types pointeur de 32 bits, et génère du code qui s'exécute sur n'importe quel système i386.

* L'-m64 option définit int de 32 bits et de long et de type pointeur à 64 bits, et génère le code pour le x86-64 l'architecture. Pour Darwin seulement l'-m64 option désactive également l'-fno-pic et -mdynamic-pas-pic options.

* L'-mx32 option définit int, long, et les types pointeur de 32 bits, et génère le code pour le x86-64 l'architecture.}

Il est également -maddress-mode=long etc.

^{-maddress-mode=long}

_{Générer du code pour de longues mode d'adresse. C'est uniquement pris en charge pour la version 64 bits et 32 bits des environnements. C'est l'adresse par défaut mode pour les environnements 64 bits.}

OriginalL'auteur Morpfh
0

Je crois que le problème avec la première question, c'est que le compilateur est le traitement de '1' comme un entier, et non pas comme un entier long. Il ne veut pas comprendre qu'après la cession.

Vous pouvez résoudre le problème en faisant:
```
unsigned long num = (unsigned long)1<<63;
```
Ne vous arrive de savoir la réponse à la deuxième partie de ma question. Sur la façon d'obtenir le non-signe étendu 32 premiers bits? Je ferais quelque chose de semblable à num = num&(unsigned long)(0xFFFFFFFF)?
J'ai répondu à la deuxième partie de votre Qn. Découvrez

OriginalL'auteur Michael
0

AFAIR code comme cela a été la source d'un bug majeur dans la reiserfs il y a quelques années:
```
unsigned long num = 1<<63;
```
Si vous parlez de x86_64, oui, beaucoup de est 64 bits et sur la plupart des autres 64 bits de linux plytforms trop. Le problème est que les deux 1 et la 63 dans votre code sont simples int, et donc le résultat n'est pas défini. Mieux utiliser
```
 unsigned long num = 1UL<<63;
```
ou
```
 unsigned long num = (unsigned long)1<<63;
```
OriginalL'auteur Gunther Piez

Vous devez vous connecter pour publier un commentaire.