Reverse Byte für 64-bit-Wert

Ich versuche zur Umkehrung der bytes bei einem 64-bit-Adress-Zeiger für einen Auftrag und haben diesen 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;
}

Aber es ruiniert alles. Jedoch, eine ähnliche Funktion funktioniert perfekt für ein 64bit lang. Ist es etwas anderes, das getan werden muss, um für Zeiger?

Könnte die Art und Weise mache ich dem Aufruf der Funktion ein Problem sein?

Einen Zeiger:

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

Lange:

*loc = swapLong(*loc);

char ist nicht der richtige Datentyp. Es ist (normalerweise) eine 8-bit-byte. Wenn Sie auf einer Plattform mit 64-bit chars, erwähnen Sie bitte, dass.
ja, es ist auf der x86_64-Architektur
Dann ein char ist 8 bit. Es ist nicht möglich halten Sie eine 64-bit-Wert.

InformationsquelleAutor nix | 2014-02-02

7

Können Sie nicht verwenden char x für einen Zeiger!!!! Ein char ist nur ein byte lang.

Müssen Sie mindestens
```
unsigned long int swapPtr(unsigned long int x) {
```
Oder besser, verwenden Sie den Typ des Zeigers
```
void* swapPtr(void* x) {
```
Ziemlich wahrscheinlich, dass dein compiler wird sich beschweren, wenn Sie starten Sie die bit-Verschiebung Zeiger; in diesem Fall sind Sie besser dran, explizit casting Ihr argument in eine vorzeichenlose 64-bit integer:
```
#include <stdint.h>
uint64_t x;
```
Beachten Sie auch, dass Sie haben, rufen Sie mit der Adresse einer Variablen, so rufen Sie mit
```
result = swapLong(&loc);
```
nicht *loc (die sieht an der Stelle, wo loc zeigt - der Wert, nicht die Adresse).

Vollständige Programm:
```
#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));
}
```
Ausgabe:
```
the address of a is 0x00007fff6b133b1b
swapping all the bytes gives 0x1b3b136bff7f0000
```
BEARBEITEN Sie könnte so etwas wie
```
#include <inttypes.h>

printf("the address of a is 0x%016" PRIx64 "\n", (uint64_t)(&a));
```
wo das makro PRIx64 erweitert in "der format-string, die Sie benötigen, um drucken Sie eine 64-bit-Zahl in hex". Es ist ein wenig sauberer als die oben genannten.

Einfach nicht mit fester Breite Typen für solch eine Aufgabe. Die geeignete Art ist uintptr_t. Zusätzlich könnte man "#if UINTPRT_SIZE > UINT32_SIZE" der Teil, der vermutet, dass der Breite ist 64-bit.
vielen Dank für die Klarstellung. Ich wusste nicht, es war ein uintptr_t - sollte gedacht haben, zu sehen. Etwas zu lernen jeden Tag!
Minor: Betrachten printf("0x016" PRIx64, (uint64_t)(&a)) oder printf("0x%016llx\n", (unsigned long long)(&a)) statt wie gebucht um das format und integer zu entsprechen?
das wäre in der Tat besser. Es gibt mehrere Möglichkeiten, wie dieser verbessert werden könnte... Könnte, wenn ich in der Nähe bin einen computer (anstatt Handy)

InformationsquelleAutor Floris
3

Hier ist eine alternative Möglichkeit für die Konvertierung einer 64-bit-Wert aus Datei oder vice-versa.

Grundsätzlich können Sie diese Methode, jeder Art, durch die Definition von var_type:
```
typedef long long var_type;
```
Reverse pointer:
```
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;
    }
}
```
Reverse-by-value:
```
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 für nette generische Lösung. (Vielleicht uint8_t eher als char wenn man wollte, zu versichern, eine 8-bit-byte-swap?)
Danke chux. Ich bin mir ziemlich sicher, dass char definiert ist als ein einzelnes byte in den standard. Machen nicht, dass das "mapping" zwischen LE und WERDEN dementsprechend? In anderen Worten, die Reihenfolge der bytes in ein multi-byte-Wort auf eine LE Prozessor ist gegenüber zum einen auf ein SICH-Prozessor, unabhängig von der Größe einer single-byte... Richtig?
char in C ist ein byte, aber ein byte in C nicht unbedingt 8 bit - ist es bei mindestens 8 bit. uint8_t in C, ist genau 8 bits. Siehe stackoverflow.com/questions/18576822/...
(siehe oben im Kommentar auch.) Von definition LE und SEIN Gegenteil um. Aber es gibt subtile Möglichkeiten, die in dieser BE/LE Geschäft, einschließlich Plattformen, mixed-endian. Ich vermute, mixed-endian ist heute obsolet und hat eine zweifelhafte Zukunft der Rücksendung. Hinweis: Einige Anwendungen müssen swap bisschen, um mit verschiedenen seriellen Kommunikation.
Also die Größe von einem byte ist unabhängig definiert, die vom compiler und von der CPU-Architektur (die bezieht sich immer auf ein byte als 8-bit-Einheit)? Seltsam... ich dachte, dass der Compiler die Definition von 16-bit-bytes wäre Compilern, die für eine zugrunde liegende Architektur, die von der gleichen "Art".

InformationsquelleAutor barak manos

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.