C-Programm zur Überprüfung von Little vs. Big Endian [duplicate]

Lesezeit: 4 Minuten

gewöhnlicher Benutzer-Avatar
gewöhnliche

Mögliches Duplikat:

C Makro-Definition zur Bestimmung der Big-Endian- oder Little-Endian-Maschine?

int main()
{
  int x = 1;

  char *y = (char*)&x;

  printf("%c\n",*y+48);
}

Bei Little Endian wird 1 ausgegeben. Bei Big Endian wird 0 ausgegeben. Ist das richtig? Oder zeigt das Setzen eines char* auf int x immer auf das niedrigstwertige Bit, unabhängig von der Endianness?

  • Siehe diese Antwort, es kann verwandt sein.

    – Sergej Kalinitschenko

    9. Oktober 2012 um 1:59 Uhr

  • @ordinary – Nur eine Anmerkung, dass Big Endian und Little Endian nicht die einzigen Optionen sind, dass nicht alle Datentypen gleich sein müssen Endianität, und dass einige Hardware zur Laufzeit konfiguriert werden kann. Wenn Sie dies wirklich überprüfen müssen, müssen Sie möglicherweise mehr Dinge überprüfen.

    – Bo Persson

    9. Oktober 2012 um 7:55 Uhr


  • Wenn Sie die Möglichkeit haben, ziehen Sie bitweise Operationen für Datentypen mit fester Breite in Betracht, um Bits zu extrahieren/zu setzen. Sie sind gemäß dieser Antwort tragbar

    – Mucaho

    30. Juli 2015 um 3:33 Uhr

  • Toller Endianness-Democode für Userland und sogar ein Kernelmodul: gitlab.com/eric.saintetienne/endianness

    – Erich

    15. April 2020 um 11:10 Uhr

  • Warum ASCII verwenden. Verwenden '0'. Warum als char und nicht als int drucken. Warum als int beginnen.

    – young_souflaki

    7. Juli 2020 um 13:52 Uhr

Benutzeravatar von Marcus
Markus

Kurz gesagt, ja.

Angenommen, wir befinden uns auf einem 32-Bit-Computer.

Wenn es sich um Little Endian handelt, wird die x im Speicher wird so etwas wie:

       higher memory
          ----->
    +----+----+----+----+
    |0x01|0x00|0x00|0x00|
    +----+----+----+----+
    A
    |
   &x

Also (char*)(&x) == 1und *y+48 == '1'. (48 ist der ASCII-Code von ‘0’)

Wenn es Big Endian ist, wird es sein:

    +----+----+----+----+
    |0x00|0x00|0x00|0x01|
    +----+----+----+----+
    A
    |
   &x

so wird dieser sein '0'.

  • Welche Bedeutung hat der zu y addierte Wert 48?

    – Abin Mathew Abraham

    1. Februar 2016 um 15:57 Uhr

  • @AbinMathewAbraham 48 ist der ASCII-Code von ‘0’ 🙂

    – Markus

    18. Februar 2016 um 8:37 Uhr

  • Ich verwende MAC OS mit Intel-Prozessoren. Es soll Little Endian sein. Jedoch, 1 scheint ein Sonderfall zu sein, denn wann 1 wird im Speicher gespeichert, es ist in Big Endian.

    – code4j

    7. März 2016 um 14:25 Uhr


  • Können Sie mir sagen, warum wir nicht einfach verwenden können (char)x == 1 ? Warum müssen wir die Adresse bekommen, sie in a konvertieren char Zeiger und dann dereferenzieren? Wird dies nicht implizit geschehen (char)x wird genutzt?

    – J…S

    28. Dezember 2018 um 11:57 Uhr


  • @J … ich glaube (char)x würde unabhängig von Endianness funktionieren. Und von “Arbeit”ich meine, es würde den Wert zuweisen 1 zu xalso wäre es nicht möglich, die Endianness auf diese Weise zu erkennen.

    – luizfls

    22. August 2019 um 17:59 Uhr

Das Folgende wird tun.

unsigned int x = 1;
printf ("%d", (int) (((char *)&x)[0]));

Und Einstellung &x zu char * ermöglicht Ihnen den Zugriff auf die einzelnen Bytes der Ganzzahl, und die Reihenfolge der Bytes hängt von der Endianness des Systems ab.

  • Keine Notwendigkeit, als unsigned int zu deklarieren. signed int reicht auch aus, weil 1 positiv ist und selbst wenn ein Bit für das Vorzeichen reserviert ist, ist es für positive Zahlen sowieso 0.

    – Kadin

    6. Juli 2016 um 22:01 Uhr

Benutzeravatar von admiring_shannon
bewundernde_shannon

Dies ist ein Big-Endian-Test von a konfigurieren Skript:

#include <inttypes.h>
int main(int argc, char ** argv){
    volatile uint32_t i=0x01234567;
    // return 0 for big endian, 1 for little endian.
    return (*((uint8_t*)(&i))) == 0x67;
}

  • Warum volatile statt const?

    – LIU Qingyuan

    10. Oktober 2020 um 8:34 Uhr

  • Ich denke, es ist eine einfache Möglichkeit, unerwünschte Compiler-Optimierungen zu vermeiden und tatsächlich die Daten in der RAM-Zelle zu betrachten, um die Antwort zu ermitteln.

    – bewundernde_shannon

    11. Oktober 2020 um 18:52 Uhr

  • thx, hier muss die Optimierung unterdrückt werden.

    – LIU Qingyuan

    13. Oktober 2020 um 3:09 Uhr

Benutzeravatar von user1668559
Benutzer1668559

Ich dachte, ich wüsste, dass ich darüber im Standard gelesen hatte; kann es aber nicht finden. Sucht weiter. Alt; antwortende Überschrift; nicht Q-tex ;P:


Das folgende Programm würde das feststellen:

#include <stdio.h>
#include <stdint.h>

int is_big_endian(void)
{
    union {
        uint32_t i;
        char c[4];
    } e = { 0x01000000 };

    return e.c[0];
}

int main(void)
{
    printf("System is %s-endian.\n",
        is_big_endian() ? "big" : "little");

    return 0;
}

Sie haben auch dieser Ansatz; von Quake II:

byte    swaptest[2] = {1,0};
if ( *(short *)swaptest == 1) {
    bigendien = false;

Und !is_big_endian() ist nicht 100% zu wenig, da es gemischt/mittel sein kann.

Glauben Sie, dass dies mit demselben Ansatz überprüft werden kann, ändern Sie nur den Wert von 0x01000000 zu dh 0x01020304 geben:

switch(e.c[0]) {
case 0x01: BIG
case 0x02: MIX
default: LITTLE

Aber da bin ich mir nicht ganz sicher…

1418730cookie-checkC-Programm zur Überprüfung von Little vs. Big Endian [duplicate]

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy