Inverser les octets de valeur 64 bits

Je suis en train d'inverser les octets pour une version 64 bits de l'adresse de pointeur pour une mission, et ont de ce code:

char swapPtr(char x){
x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32;
x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16;
x = (x & 0x00FF00FF00FF00FF) << 8  | (x & 0xFF00FF00FF00FF00) >> 8;
return x;
}

Mais, c'est juste les dégâts tout en place. Cependant, une fonction similaire fonctionne parfaitement pour un 64 bits de long. Est-il quelque chose de différent qui doit être fait pour les pointeurs?

Pourrait la façon dont je suis en train de faire l'appel de la fonction?

Pour un pointeur:

*(char*)loc = swapPtr(*(char*)loc);

Pour une longue:

*loc = swapLong(*loc);

char n'est pas le bon type de données. C'est (généralement) un 8 bits de l'octet. Si vous êtes sur une plate-forme 64 bits de caractères, veuillez le mentionner.
oui, c'est sur l'architecture x86_64
Ensuite, un char est de 8 bits. Il ne peut pas tenir un 64 bits de la valeur.

OriginalL'auteur nix | 2014-02-02

7

Vous ne pouvez pas utiliser char x pour un pointeur!!!! Un char n'est qu'un seul octet de long.

Vous avez besoin d'au moins
```
unsigned long int swapPtr(unsigned long int x) {
```
Ou mieux, utiliser le type de l'indicateur
```
void* swapPtr(void* x) {
```
Tout à fait probable que votre compilateur va se plaindre lorsque vous démarrez le décalage de bits pointeurs; dans ce cas, vous êtes mieux explicitement le moulage de votre argument un entier non signé entier de 64 bits:
```
#include <stdint.h>
uint64_t x;
```
Notez également que vous devez appeler avec l'adresse d'une variable, de sorte que vous appelez avec
```
result = swapLong(&loc);
```
pas *loc (qui regarde à l'endroit où loc pointe - à la valeur, non pas l'adresse).

Programme complet:
```
#include <stdio.h>
#include <stdint.h>

uint64_t swapLong(void *X) {
  uint64_t x = (uint64_t) X;
x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32;
x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16;
x = (x & 0x00FF00FF00FF00FF) << 8  | (x & 0xFF00FF00FF00FF00) >> 8;
return x;
}

int main(void) {
  char a;
  printf("the address of a is 0x%016llx\n", (uint64_t)(&a));
  printf("swapping all the bytes gives 0x%016llx\n",(uint64_t)swapLong(&a));
}
```
De sortie:
```
the address of a is 0x00007fff6b133b1b
swapping all the bytes gives 0x1b3b136bff7f0000
```
MODIFIER vous pouvez utiliser quelque chose comme
```
#include <inttypes.h>

printf("the address of a is 0x%016" PRIx64 "\n", (uint64_t)(&a));
```
où la macro PRIx64 s'étend dans "la chaîne de format, vous devez imprimer un 64 bits en hexadécimal". Il est un peu plus propre que le précédent.

Il suffit de ne pas utiliser une largeur fixe de types pour une telle tâche. Le type est uintptr_t. En outre, vous pourriez "#if UINTPRT_SIZE > UINT32_SIZE" la partie qui suppose que la largeur est de 64 bits.
merci pour la clarification. Je ne savais pas il y avait un uintptr_t - faut-il avoir pensé à regarder. Apprendre quelque chose tous les jours!
Mineur: Considérer printf("0x016" PRIx64, (uint64_t)(&a)) ou printf("0x%016llx\n", (unsigned long long)(&a)) au lieu de posté pour obtenir le format et le nombre entier de match?
ce serait en effet mieux. Il ya plusieurs façons cela pourrait être amélioré... Peut le faire quand je suis à proximité d'un ordinateur (plutôt que par téléphone)

OriginalL'auteur Floris
3

Ici est une autre façon pour la conversion d'une valeur de 64 bits de CHIER ou vice-versa.

Vous pouvez appliquer cette méthode n'importe quel type, par définition var_type:
```
typedef long long var_type;
```
Inverse par pointeur:
```
void swapPtr(var_type* x)
{
    char* px = (char*)x;
    for (int i=0; i<sizeof(var_type)/2; i++)
    {
        char temp = px[i];
        px[i] = px[sizeof(var_type)-1-i];
        px[sizeof(var_type)-1-i] = temp;
    }
}
```
Inverse par valeur:
```
var_type swapVal(var_type x)
{
    var_type y;
    char* px = (char*)&x;
    char* py = (char*)&y;
    for (int i=0; i<sizeof(var_type); i++)
        py[i] = px[sizeof(var_type)-1-i];
    return y;
}
```
+1 pour la belle solution générique. (Peut-être uint8_t plutôt que char si l'on voulait assurer un octet de 8 bits swap?)
Merci chux. Je suis assez sûr que char est défini comme un octet dans la norme. N'est-ce pas le "mapping" entre LE et ÊTRE en conséquence? En d'autres termes, l'ordre des octets dans un multi-byte word sur un LE processeur est à l'opposé de celui d'un ÊTRE processeur, quelle que soit la taille d'un octet unique... Correct?
char dans C est un byte, mais un byte en C n'est pas nécessairement 8 bits c'est à moins 8 bits. uint8_t, C, est exactement de 8 bits. Voir stackoverflow.com/questions/18576822/...
(voir le commentaire ci-dessus.) Par définition CHIER et de l'avoir en face de l'ordre. Mais il y a de subtiles possibilités à cet ÊTRE/LE business, y compris les plates-formes qui utilisent mixte endian. Je soupçonne mixte endian est obsolète aujourd'hui et qui a un avenir incertain du retour. Remarque: Certaines applications ont besoin de swap peu commander avec diverses communications série.
De sorte que la taille d'un seul octet est indépendamment défini par le compilateur et par l'architecture du PROCESSEUR (qui se réfère toujours à un octet comme un 8-bit de l'unité)? Étrange... j'ai pensé que les compilateurs définition de 16 bits octets serait compilateurs désigné pour une architecture sous-jacente de la même "type".

OriginalL'auteur barak manos

Vous devez vous connecter pour publier un commentaire.