wie cast uint8_t-array von 4 auf uint32_t in c

Ich versuche zu casten ein array von uint8_t auf ein array uint32_t, aber es scheint nicht zu funktionieren.

Kann einer mir helfen auf diese. Ich brauche, um uint8_t Werte uint32_t.

Ich kann dies mit der Verschiebung, aber ich denke, es gibt eine einfache Möglichkeit.

uint32_t *v4full;
v4full=( uint32_t *)v4;
while (*v4full) {
    if (*v4full & 1)
        printf("1");
    else
        printf("0");

    *v4full >>= 1;
}
printf("\n");

Können Sie zeigen den Bau des Quell-Arrays?
sorry, habe ich korrigiert-Typ-Fehler. Quell-array-Konstruktion in4_pton(token,-1,&v4,-1,&c); dieser wandelt eine Zeichenkette in eine ip-Adresse und legen Sie es in der v4-array
Okay. Nicht werfen die Zeiger in einer solchen Art und Weise das Programm denkt, es ist der Blick auf einen 32-bit-Wort. Wenn Sie brauchen, um die Arbeit mit int, iterate über die original-Vektor, der die 8-bit-bytes, und weisen Sie dann das byte auf eine einfache int variable; z.B., für (int n=0; n < 4; n++) { int i = (int)v4[n]; ...}, es sei denn, Sie wollen den gesamten Vektor als kombinierte 32-bit-Wort...
Nur um zu klären: können wir denken, dass der v4 als uint8_t v4[4], und Sie wollen, dass Sie als ein einzelnes 32-bit-Zahl?

InformationsquelleAutor user2714949 | 2013-11-30

c casting

11

Angesichts der Notwendigkeit, uint8_t Werte uint32_t, und die Spezifikationen auf der in4_pton()...

Versuchen, diese mit einer möglichen Korrektur des byte-Reihenfolge:
```
uint32_t i32 = v4[0] | (v4[1] << 8) | (v4[2] << 16) | (v4[3] << 24);
```
- Ihre Vermutung ist so gut wie meine..., wenn er muss die byte-Reihenfolge Umgekehrt, Ihre Antwort ist korrekt (also ein +1 nur für den Fall). Wenn er nicht, meiner ist geringfügig kompakter. Es vielleicht, hängt von der Rechnerarchitektur (big/little endian...)
- Vereinbart. Es ist jetzt genug, mit zu arbeiten. Dito auf +1
InformationsquelleAutor bvj
4

Wenn v4full ist ein Zeiger, dann die Linie
```
uint32_t *v4full;
v4full=( uint32_t)&v4;
```
Sollte einen Fehler auslösen, oder zumindest eine compiler-Warnung. Vielleicht haben Sie zu tun bedeuten
```
uint32_t *v4full;
v4full=( uint32_t *) v4;
```
Wo ich davon ausgehen v4 selbst ist ein Zeiger auf eine uint8 array. Ich weiß, ich bin Extrapolation aus unvollständiger Informationen verursacht wurden...

BEARBEITEN da oben zu haben scheint, behandelt ein Tippfehler, lassen Sie uns versuchen Sie es erneut.

Den folgenden code-snippet funktioniert wie erwartet - und ich glaube, Sie wollen, dass Ihr code, um zu arbeiten. Bitte kommentieren Sie diese - wie ist dieser code nicht zu tun, was Sie wollen?
```
#include <stdio.h>
#include <inttypes.h>

int main(void) {
    uint8_t v4[4] = {1,2,3,4};
    uint32_t *allOfIt;
    allOfIt = (uint32_t*)v4;
    printf("the number is %08x\n", *allOfIt);
}
```
Ausgabe:
```
the number is 04030201
```
Hinweis - die Reihenfolge der bytes in der gedruckten Zahl ist es Umgekehrt - Sie bekommen 04030201 statt 01020304 als Sie erwartet haben könnte /wollte. Dies ist, weil meine Maschine (x86-Architektur) ist little-endian. Wenn Sie sicherstellen möchten, dass die Reihenfolge der bytes ist die Art, wie Sie es wollen (in anderen Worten, das element [0] entspricht dem höchstwertigen byte) Sie sind besser dran mit @bvj-Lösung - schalten jedes der vier bytes in der richtigen position in Ihrem 32-bit-integer.

Kann man übrigens sehen, diese frühere Antwort für einen sehr effizienten Weg, dies zu tun, wenn nötig (sagt der compiler zu verwenden errichtet in der Anweisung von der CPU).
- tut mir Leid mein schlechtes korrigiert es
- Ist es Ihr Eindruck, der op will dereferenzieren das gesamte array als Zeiger auf eine 32-bit-Wort?
- Aber es gibt ein Potenzial byte-order-Problem angesichts der v4-array ist eine binäre Darstellung einer IPv4-Adresse.
- ja, es ist - siehe mein Kommentar auf deine Antwort...
- Nur zur info - technisch allOfIt = (uint32_t*)v4 ist illegal unter dem c99-standard. Es kann einzuführen bugs in den code entweder in der Zukunft oder sogar in aktuellen Compilern auf höheren Optimierung.
- Ich wusste nicht,- mein C ist eher älter als '99... ich nehme an, Sie sind immer noch erlaubt, eine union der beiden Arten? Das wäre ein paar mehr Zeilen code...
- Union funktioniert immer noch AFAIK, aber ist auch gegen die standard (weil Sie würde das schreiben einem Vorstandsmitglied und dem Lesen von anderen, das ist technisch nicht erlaubt in Gewerkschaften). Leider gibt C und C++ bewegen sich in Richtungen, die es verbieten, jede Art von "smart" low-level-Implementierungen (ein Weiteres Beispiel, das ich hasse: signed overflow Undefiniertes Verhalten und nicht erlaubt 🙁 ). Ich bin sicher, Sie haben Ihre Gründe, aber ich mag es nicht 🙁
- danke! Ich dachte, das ganze point von den Gewerkschaften war zu schreiben und zu Lesen das andere... Wenn ich kann nicht mit low-level-code könnte ich auch wechseln, um Java. Sheesh. Ich denke, das ist, warum ich nicht schalten C99 auf meinem compiler (es ist nicht standardmäßig aktiviert, das lässt mich selig stecken in den Dunklen Zeiten, offenbar.) Kennen Sie eine überzeugende Grund für mich das "upgrade"? (Alter Hund und all das...)
- blog.qt.digia.com/blog/2011/06/10/... gibt einige Hintergrundinformationen. Ich stand geschult...
InformationsquelleAutor Floris
4

Gibt es ein problem mit deinem Beispiel - eigentlich mit dem, was Sie versuchen zu tun, (da Sie nicht wollen, dass die Schichten).

Sehen, es ist eine wenig bekannte Tatsache, aber Sie sind nicht erlaubt zu wechseln-Zeiger-Typen in dieser Weise

speziell, code wie das ist illegal:
```
type1 *vec1=...;
type2 *vec2=(type2*)vec1;
//do stuff with *vec2
```
Der einzige Fall, wo dies legal ist, ist wenn type2 ist char (oder unsigned char oder const char etc.), aber wenn type2 beliebiger anderer Typ (uint32_t in deinem Beispiel) es ist gegen die Norm und einführen können Fehler in Ihrem code, wenn Sie kompilieren mit -O2 oder -O3 Optimierung.

Nennt sich das "strict-aliasing-Regel", und es ermöglicht Compiler davon ausgehen, dass die Zeiger der verschiedenen Arten niemals zu entsprechenden Punkte im Memory - Speicher, so dass, wenn Sie ändern die Erinnerung an einen pointer, die den compiler nicht haben, um neu zu laden, alle anderen Zeiger.

Es ist schwer für Compiler, um Instanzen zu suchen, bricht diese Regel, es sei denn, Sie machen es schmerzlich klar, es. Zum Beispiel, wenn Sie den code ändern, um dies zu tun:
```
uint32_t v4full=*((uint32_t*)v4);
```
und kompilieren Sie mit -O3 -Wall (ich verwende gcc), erhalten Sie die Warnung:
```
warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
```
So kann man nicht vermeiden, mit den Verschiebungen.

Hinweis: es wird Arbeit am unteren Optimierung der Einstellungen, und es funktioniert auch in höheren Einstellungen, wenn Sie ändern Sie nie die info Zeiger auf die von v4 und v4_full. Es wird funktionieren, aber es ist noch ein bug, und immer noch "gegen die Regeln".

InformationsquelleAutor rabensky

Ist dies eine Lösung:

/* convert character array to integer */
uint32_t buffChar_To_Int(char *array, size_t n){
    int number = 0;
    int mult = 1;

    n = (int)n < 0 ? -n : n;       /* quick absolute value check  */

    /* for each character in array */
    while (n--){
        /* if not digit or '-', check if number > 0, break or continue */
        if((array[n] < '0' || array[n] > '9') && array[n] != '-'){
            if(number)
               break;
            else
               continue;
        }

        if(array[n] == '-'){      /* if '-' if number, negate, break */
            if(number){
               number = -number;
               break;
            }
        }
        else{      /* convert digit to numeric value   */
            number += (array[n] - '0') * mult;
            mult *= 10;
        }
    }
    return number;
}

InformationsquelleAutor F. Mercado

0

Einem anderen Problem, das macht dieser code nicht portabel ist, dass viele Architekturen erfordern eine uint32_t ausgerichtet werden auf einem vier-byte-Grenze, sondern ermöglichen uint8_t zu haben, eine Adresse angeben. Der Aufruf dieses Codes auf einer falsch ausgerichteten array würde dann der schaltplanbearbeitung zu undefiniertem Verhalten wie z.B. Absturz des Programms mit SIGBUS. Auf diesen Maschinen, ist die einzige Möglichkeit zum umwandeln eines beliebigen uint8_t[] zu einem uint32_t[] ist memcpy() den Inhalt. (Wenn Sie dies tun, in einem vier-byte-Blöcken, sollte der compiler optimieren, um je nachdem, welcher einen nichtlinearen Last-oder zwei-Lasten-und-eines-shift ist effizienter auf Ihre Architektur.)

Wenn Sie haben die Kontrolle über die Erklärung des source-array, können Sie #include <stdalign.h> und dann erklären alignas(uint32_t) uint8_t bytes[]. Die klassische Lösung ist, um zu erklären, sowohl das byte-array und die 32-bit-Werte als Mitglieder einer union - und type-pun zwischen Ihnen. Es ist auch sicher zu bedienen Zeiger eingeholt malloc(), denn diese sind garantiert passend ausgerichtet.

InformationsquelleAutor Davislor
-1

Eine weitere Lösung:
```
u32 ip;

if (!in4_pton(str, -1, (u8 *)&ip, -1, NULL))
      return -EINVAL;

... use ip as it defined above - (as variable of type u32)
```
Hier verwenden wir das Ergebnis der in4_pton Funktion (ip) ohne zusätzliche Variablen und Gussteilen.
- Bitte erklären, was dein code macht und warum es das problem zu lösen. Eine Antwort, die nur die code enthält (auch wenn es funktioniert) in der Regel nicht helfen, die OP zu verstehen, Ihr problem.
- Siehe zweiter Kommentar auf die Frage - user2714949 die Frage nach nutzen Ergebnis in4_pton. Meine Antwort ist ein weiterer Ansatz, um diese Funktion zu nutzen, ohne zusätzliche Variablen und Gussteilen.
InformationsquelleAutor dimcha

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.