¿Hay alguna forma programática para detectar si estás o no en una arquitectura big-endian o little-endian? Necesito poder escribir código que se ejecute en un sistema Intel o PPC y usar exactamente el mismo código (es decir, sin compilación condicional).

No me gusta el método basado en el tipo de juego de palabras: a menudo el compilador lo advertirá. ¡Para eso son exactamente los sindicatos!

bool is_big_endian(void)
{
    union {
        uint32_t i;
        char c[4];
    } bint = {0x01020304};

    return bint.c[0] == 1; 
}

El principio es equivalente al caso tipo sugerido por otros, pero esto es más claro y, según C99, se garantiza que es correcto. gcc prefiere esto en comparación con el elenco de puntero directo.

Esto también es mucho mejor que arreglar el endianness en el momento de la compilación: para sistemas operativos que admiten arquitectura múltiple (binario gordo en Mac os x, por ejemplo), esto funcionará tanto para ppc / i386, mientras que de lo contrario es muy fácil estropear las cosas .

Puede hacerlo estableciendo un int y enmascarando bits, pero probablemente la forma más fácil es usar las operaciones de conversión de bytes de red incorporadas (ya que el orden de bytes de red siempre es big endian).

if ( htonl(47) == 47 ) {
  // Big endian
} else {
  // Little endian.
}

El violín podría ser más rápido, pero de esta manera es simple, directo y bastante imposible de estropear.

Por favor vea este artículo :

Aquí hay un código para determinar cuál es el tipo de su máquina

int num = 1;
if(*(char *)&num == 1)
{
    printf("\nLittle-Endian\n");
}
else
{
    printf("Big-Endian\n");
}

Puede usarlo std::endiansi tiene acceso al compilador C ++ 20, como GCC 8+ o Clang 7+.

Nota: std::endiancomenzó en <type_traits>pero se mudó a <bit>la reunión de 2019 en Colonia. GCC 8, Clang 7, 8 y 9 lo tienen adentro <type_traits>mientras que GCC 9+ y Clang 10+ lo tienen adentro <bit>.

#include <bit>

if constexpr (std::endian::native == std::endian::big)
{
    // Big endian system
}
else if constexpr (std::endian::native == std::endian::little)
{
    // Little endian system
}
else
{
    // Something else
}

Esto normalmente se realiza en tiempo de compilación (especialmente por razones de rendimiento) mediante el uso de los archivos de encabezado disponibles en el compilador o crea el tuyo propio. En Linux tiene el archivo de encabezado "/usr/include/endian.h"

Me sorprendió que nadie haya mencionado las macros que el preprocesador define por defecto. Si bien estos variarán dependiendo de su plataforma; son mucho más limpios que tener que escribir su propio cheque endian.

Por ejemplo; si miramos las macros integradas que GCC define (en una máquina X86-64):

:| gcc -dM -E -x c - |grep -i endian
#define __LITTLE_ENDIAN__ 1

En una máquina PPC obtengo:

:| gcc -dM -E -x c - |grep -i endian
#define __BIG_ENDIAN__ 1
#define _BIG_ENDIAN 1

(La :| gcc -dM -E -x c -magia imprime todas las macros integradas).

Ehm ... Me sorprende que nadie se haya dado cuenta de que el compilador simplemente optimizará la prueba y pondrá un resultado fijo como valor de retorno. Esto hace que todos los ejemplos de código anteriores sean efectivamente inútiles. ¡Lo único que se devolvería es la resistencia en tiempo de compilación! Y sí, probé todos los ejemplos anteriores. Aquí hay un ejemplo con MSVC 9.0 (Visual Studio 2008).

Código C puro

int32 DNA_GetEndianness(void)
{
    union 
    {
        uint8  c[4];
        uint32 i;
    } u;

    u.i = 0x01020304;

    if (0x04 == u.c[0])
        return DNA_ENDIAN_LITTLE;
    else if (0x01 == u.c[0])
        return DNA_ENDIAN_BIG;
    else
        return DNA_ENDIAN_UNKNOWN;
}

Desmontaje

PUBLIC  _DNA_GetEndianness
; Function compile flags: /Ogtpy
; File c:\development\dna\source\libraries\dna\endian.c
;   COMDAT _DNA_GetEndianness
_TEXT   SEGMENT
_DNA_GetEndianness PROC                 ; COMDAT

; 11   :     union 
; 12   :     {
; 13   :         uint8  c[4];
; 14   :         uint32 i;
; 15   :     } u;
; 16   : 
; 17   :     u.i = 1;
; 18   : 
; 19   :     if (1 == u.c[0])
; 20   :         return DNA_ENDIAN_LITTLE;

    mov eax, 1

; 21   :     else if (1 == u.c[3])
; 22   :         return DNA_ENDIAN_BIG;
; 23   :     else
; 24   :        return DNA_ENDIAN_UNKNOWN;
; 25   : }

    ret
_DNA_GetEndianness ENDP
END

Quizás sea posible desactivar CUALQUIER optimización de tiempo de compilación solo para esta función, pero no lo sé. De lo contrario, es posible codificarlo en el ensamblaje, aunque eso no es portátil. E incluso entonces, incluso eso podría optimizarse. Me hace pensar que necesito un ensamblador realmente malo, implementar el mismo código para todas las CPU / conjuntos de instrucciones existentes, y bueno ... no importa.

Además, alguien aquí dijo que la resistencia no cambia durante el tiempo de ejecución. INCORRECTO. Hay máquinas bi-endian por ahí. Su resistencia puede variar durante la ejecución. TAMBIÉN, no solo hay Little Endian y Big Endian, sino también otras endianidades (qué palabra).

Odio y amo la codificación al mismo tiempo ...

Declarar una variable int:

int variable = 0xFF;

Ahora use punteros char * para varias partes y verifique qué hay en esas partes.

char* startPart = reinterpret_cast<char*>( &variable );
char* endPart = reinterpret_cast<char*>( &variable ) + sizeof( int ) - 1;

Dependiendo de cuál apunta al byte 0xFF ahora puede detectar endianness. Esto requiere sizeof (int)> sizeof (char), pero definitivamente es cierto para las plataformas discutidas.

Para más detalles, puede consultar este artículo del proyecto de código Conceptos básicos sobre Endianness :

¿Cómo probar dinámicamente el tipo Endian en tiempo de ejecución?

Como se explica en las Preguntas frecuentes sobre Animación por computadora, puede usar la siguiente función para ver si su código se ejecuta en un sistema Little-o Big-Endian: Contraer

#define BIG_ENDIAN      0
#define LITTLE_ENDIAN   1

int TestByteOrder()
{
   short int word = 0x0001;
   char *byte = (char *) &word;
   return(byte[0] ? LITTLE_ENDIAN : BIG_ENDIAN);
}

Este código asigna el valor 0001h a un entero de 16 bits. Luego se asigna un puntero de caracteres para apuntar al primer byte (menos significativo) del valor entero. Si el primer byte del entero es 0x01h, entonces el sistema es Little-Endian (el 0x01h está en la dirección más baja o menos significativa). Si es 0x00h, entonces el sistema es Big-Endian.

La forma en C ++ ha sido usar boost , donde las comprobaciones y los moldes del preprocesador se dividen en compartimentos dentro de bibliotecas probadas a fondo.

La Biblioteca Predef (boost / predef.h) reconoce cuatro tipos diferentes de endianness .

La biblioteca endiana fue planeada para ser enviada al estándar C ++, y soporta una amplia variedad de operaciones en datos sensibles a .

Como se indicó en las respuestas anteriores, Endianness será parte de c ++ 20.

A menos que esté utilizando un marco que ha sido portado a procesadores PPC e Intel, tendrá que hacer compilaciones condicionales, ya que las plataformas PPC e Intel tienen arquitecturas de hardware, tuberías, buses, etc. completamente diferentes. Esto hace que el código de ensamblaje sea completamente diferente entre los dos.

En cuanto a encontrar endianness, haga lo siguiente:

short temp = 0x1234;
char* tempChar = (char*)&temp;

Obtendrá tempChar para que sea 0x12 o 0x34, de donde conocerá la resistencia.

Haría algo como esto:

bool isBigEndian() {
    static unsigned long x(1);
    static bool result(reinterpret_cast<unsigned char*>(&x)[0] == 0);
    return result;
}

En este sentido, obtendría una función eficiente en el tiempo que solo realiza el cálculo una vez.

Como se indicó anteriormente, use trucos de unión.

Sin embargo, existen pocos problemas con los que se aconsejaron anteriormente, sobre todo porque el acceso a la memoria no alineado es notoriamente lento para la mayoría de las arquitecturas, y algunos compiladores ni siquiera reconocerán dichos predicados constantes, a menos que las palabras estén alineadas.

Debido a que la simple prueba endian es aburrida, aquí va la función (plantilla) que cambiará la entrada / salida del entero arbitrario de acuerdo con sus especificaciones, independientemente de la arquitectura del host.

#include <stdint.h>

#define BIG_ENDIAN 1
#define LITTLE_ENDIAN 0

template <typename T>
T endian(T w, uint32_t endian)
{
    // this gets optimized out into if (endian == host_endian) return w;
    union { uint64_t quad; uint32_t islittle; } t;
    t.quad = 1;
    if (t.islittle ^ endian) return w;
    T r = 0;

    // decent compilers will unroll this (gcc)
    // or even convert straight into single bswap (clang)
    for (int i = 0; i < sizeof(r); i++) {
        r <<= 8;
        r |= w & 0xff;
        w >>= 8;
    }
    return r;
};

Uso:

Para convertir de endian dado a host, use:

host = endian(source, endian_of_source)

Para convertir de host endian a endian dado, use:

output = endian(hostsource, endian_you_want_to_output)

El código resultante es tan rápido como escribir ensamblaje manual en clang, en gcc es un poco más lento (desenrollado &, <<, >>, | para cada byte) pero aún decente.

bool isBigEndian()
{
    static const uint16_t m_endianCheck(0x00ff);
    return ( *((uint8_t*)&m_endianCheck) == 0x0); 
}

¡No utilices a union!

C ++ no permite la escritura de tipos a través de unions!
¡Leer desde un campo sindical que no fue el último campo escrito es un comportamiento indefinido !
Muchos compiladores admiten hacerlo como extensiones, pero el lenguaje no garantiza.

Vea esta respuesta para más detalles:

https://stackoverflow.com/a/11996970

Solo hay dos respuestas válidas que están garantizadas para ser portátiles.

La primera respuesta, si tiene acceso a un sistema que admite C ++ 20,
es usarlo std::endiandesde el <type_traits>encabezado.

(Al momento de escribir, C ++ 20 aún no se ha lanzado, pero a menos que algo afecte std::endian la inclusión, esta será la forma preferida de probar la resistencia en tiempo de compilación desde C ++ 20 en adelante).

C ++ 20 en adelante

constexpr bool is_little_endian = (std::endian::native == std::endian::little);

Antes de C ++ 20, la única respuesta válida es almacenar un número entero y luego inspeccionar su primer byte a través del tipo punteo.
A diferencia del uso de unions, esto está expresamente permitido por el sistema de tipos de C ++.

También es importante recordar que para una portabilidad óptima se static_castdebe usar,
porque la reinterpret_castimplementación está definida.

Si un programa intenta acceder al valor almacenado de un objeto a través de un valor gl diferente de uno de los siguientes tipos, el comportamiento es indefinido: ... a charo unsigned chartipo.

C ++ 11 en adelante

enum class endianness
{
    little = 0,
    big = 1,
};

inline endianness get_system_endianness()
{
    const int value { 0x01 };
    const void * address = static_cast<const void *>(&value);
    const unsigned char * least_significant_address = static_cast<const unsigned char *>(address);
    return (*least_significant_address == 0x01) ? endianness::little : endianness::big;
}

C ++ 11 en adelante (sin enumeración)

inline bool is_system_little_endian()
{
    const int value { 0x01 };
    const void * address = static_cast<const void *>(&value);
    const unsigned char * least_significant_address = static_cast<const unsigned char *>(address);
    return (*least_significant_address == 0x01);
}

C ++ 98 / C ++ 03

inline bool is_system_little_endian()
{
    const int value = 0x01;
    const void * address = static_cast<const void *>(&value);
    const unsigned char * least_significant_address = static_cast<const unsigned char *>(address);
    return (*least_significant_address == 0x01);
}

union {
    int i;
    char c[sizeof(int)];
} x;
x.i = 1;
if(x.c[0] == 1)
    printf("little-endian\n");
else    printf("big-endian\n");

Esta es otra solución. Similar a la solución de Andrew Hare.

no probado, pero en mi opinión, esto debería funcionar? porque será 0x01 en little endian y 0x00 en big endian?

bool runtimeIsLittleEndian(void)
{
 volatile uint16_t i=1;
 return  ((uint8_t*)&i)[0]==0x01;//0x01=little, 0x00=big
}

Declarar:

Mi publicación inicial se declara incorrectamente como "tiempo de compilación". No lo es, incluso es imposible en el estándar actual de C ++. Constexpr NO significa que la función siempre realiza cómputos en tiempo de compilación. Gracias Richard Hodges por la corrección.

Tiempo de compilación, no macro, solución C ++ 11 constexpr:

union {
  uint16_t s;
  unsigned char c[2];
} constexpr static  d {1};

constexpr bool is_little_endian() {
  return d.c[0] == 1;
}

También puede hacerlo a través del preprocesador utilizando algo como el archivo de encabezado boost que se puede encontrar boost endian

A menos que el encabezado endian sea solo para GCC, proporciona macros que puede usar.

#include "endian.h"
...
if (__BYTE_ORDER == __LITTLE_ENDIAN) { ... }
else if (__BYTE_ORDER == __BIG_ENDIAN) { ... }
else { throw std::runtime_error("Sorry, this version does not support PDP Endian!");
...

Si no desea una compilación condicional, simplemente puede escribir código independiente endian. Aquí hay un ejemplo (tomado de Rob Pike ):

Lectura de un entero almacenado en little-endian en el disco, de manera independiente endian:

i = (data[0]<<0) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);

El mismo código, tratando de tener en cuenta la resistencia de la máquina:

i = *((int*)data);
#ifdef BIG_ENDIAN
/* swap the bytes */
i = ((i&0xFF)<<24) | (((i>>8)&0xFF)<<16) | (((i>>16)&0xFF)<<8) | (((i>>24)&0xFF)<<0);
#endif

int i=1;
char *c=(char*)&i;
bool littleendian=c;

¿Qué tal esto?

#include <cstdio>

int main()
{
    unsigned int n = 1;
    char *p = 0;

    p = (char*)&n;
    if (*p == 1)
        std::printf("Little Endian\n");
    else 
        if (*(p + sizeof(int) - 1) == 1)
            std::printf("Big Endian\n");
        else
            std::printf("What the crap?\n");
    return 0;
}

Aquí hay otra versión C. Define una macro llamada wicked_cast()para el punteo de tipo en línea a través de literales de unión C99 y el __typeof__operador no estándar .

#include <limits.h>

#if UCHAR_MAX == UINT_MAX
#error endianness irrelevant as sizeof(int) == 1
#endif

#define wicked_cast(TYPE, VALUE) \
    (((union { __typeof__(VALUE) src; TYPE dest; }){ .src = VALUE }).dest)

_Bool is_little_endian(void)
{
    return wicked_cast(unsigned char, 1u);
}

Si los enteros son valores de un solo byte, la endianidad no tiene sentido y se generará un error en tiempo de compilación.

Los compiladores forma de C (al menos todos los que conozco de) trabajar el orden de bits ha de ser decidido en tiempo de compilación. Incluso para procesadores biendianos (como ARM och MIPS) debe elegir endianness en tiempo de compilación. Además, el endianness se define en todos los formatos de archivo comunes para ejecutables (como ELF). Aunque es posible crear un blob binario de código biandian (¿para algún exploit de servidor ARM tal vez?), Probablemente tenga que hacerse en ensamblador.

Como señaló Coriiander, la mayoría (si no todos) de esos códigos aquí se optimizarán en el momento de la compilación, por lo que los archivos binarios generados no verificarán la "endianness" en el tiempo de ejecución.

Se ha observado que un ejecutable dado no debería ejecutarse en dos órdenes de bytes diferentes, pero no tengo idea de si ese es siempre el caso, y me parece un truco comprobar en el momento de la compilación. Entonces codifiqué esta función:

#include <stdint.h>

int* _BE = 0;

int is_big_endian() {
    if (_BE == 0) {
        uint16_t* teste = (uint16_t*)malloc(4);
        *teste = (*teste & 0x01FE) | 0x0100;
        uint8_t teste2 = ((uint8_t*) teste)[0];
        free(teste);
        _BE = (int*)malloc(sizeof(int));
        *_BE = (0x01 == teste2);
    }
    return *_BE;
}

MinGW no pudo optimizar este código, a pesar de que optimiza los otros códigos aquí. Creo que es porque dejo el valor "aleatorio" que estaba alojado en la memoria de bytes más pequeña como estaba (al menos 7 de sus bits), por lo que el compilador no puede saber cuál es ese valor aleatorio y no se optimiza La función de distancia.

También he codificado la función para que la verificación solo se realice una vez y el valor de retorno se almacene para las próximas pruebas.

Si bien no hay una forma rápida y estándar de determinarlo, esto lo generará:

#include <stdio.h> 
int main()  
{ 
   unsigned int i = 1; 
   char *c = (char*)&i; 
   if (*c)     
       printf("Little endian"); 
   else
       printf("Big endian"); 
   getchar(); 
   return 0; 
} 

Ver Endianness - C-Level Code illustration.

// assuming target architecture is 32-bit = 4-Bytes
enum ENDIANNESS{ LITTLEENDIAN , BIGENDIAN , UNHANDLE };


ENDIANNESS CheckArchEndianalityV1( void )
{
    int Endian = 0x00000001; // assuming target architecture is 32-bit    

    // as Endian = 0x00000001 so MSB (Most Significant Byte) = 0x00 and LSB (Least     Significant Byte) = 0x01
    // casting down to a single byte value LSB discarding higher bytes    

    return (*(char *) &Endian == 0x01) ? LITTLEENDIAN : BIGENDIAN;
} 

Estaba revisando el libro de texto: Sistema informático: la perspectiva de un programador , y hay un problema para determinar qué endian es esto por el programa C.

Usé la función del puntero para hacer eso de la siguiente manera:

#include <stdio.h>

int main(void){
    int i=1;
    unsigned char* ii = &i;

    printf("This computer is %s endian.\n", ((ii[0]==1) ? "little" : "big"));
    return 0;
}

Como int ocupa 4 bytes, y char ocupa solo 1 bytes. Podríamos usar un puntero de caracteres para señalar el int con el valor 1. Por lo tanto, si la computadora es little endian, el carácter al que apunta el puntero de caracteres tiene el valor 1; de lo contrario, su valor debería ser 0.