Existe uma maneira programática de detectar se você está ou não em uma arquitetura big-endian ou little-endian? Eu preciso ser capaz de escrever código que será executado em um sistema Intel ou PPC e usar exatamente o mesmo código (ou seja, sem compilação condicional).

Não gosto do método com base no tipo de punção - ele geralmente é avisado pelo compilador. É exatamente para isso que servem os sindicatos!

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

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

O princípio é equivalente ao tipo de caso, conforme sugerido por outros, mas isso é mais claro - e de acordo com C99, é garantido que ele esteja correto. O gcc prefere isso em comparação com a conversão direta do ponteiro.

Isso também é muito melhor do que corrigir o endianness em tempo de compilação - para sistemas operacionais que suportam multi-arquitetura (binário gordo no Mac OS x, por exemplo), isso funcionará para o ppc / i386, embora seja muito fácil bagunçar as coisas .

Você pode fazer isso definindo um int e mascarando os bits, mas provavelmente a maneira mais fácil é usar as operações de conversão de bytes de rede integradas (uma vez que a ordem de bytes de rede é sempre grande endian).

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

A manipulação de bits pode ser mais rápida, mas dessa maneira é simples, direta e praticamente impossível de bagunçar.

Por favor, veja este artigo :

Aqui está um código para determinar qual é o tipo da sua máquina

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

Você pode usar std::endianse tiver acesso ao compilador C ++ 20, como GCC 8+ ou Clang 7+.

Nota: std::endiancomeçou em, <type_traits>mas foi transferido para <bit>a reunião de 2019 em Colônia. GCC 8, Clang 7, 8 e 9 estão dentro, <type_traits>enquanto GCC 9+ e Clang 10+ estão dentro <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
}

Isso normalmente é feito em tempo de compilação (especialmente por motivos de desempenho) usando os arquivos de cabeçalho disponíveis no compilador ou crie seus próprios. No Linux, você tem o arquivo de cabeçalho "/usr/include/endian.h"

Surpreendi que ninguém tenha mencionado as macros que o pré-processador define por padrão. Embora isso varie dependendo da sua plataforma; eles são muito mais limpos do que ter que escrever seu próprio cheque endian.

Por exemplo; se observarmos as macros internas definidas pelo GCC (em uma máquina X86-64):

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

Em uma máquina PPC, recebo:

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

(A :| gcc -dM -E -x c -mágica imprime todas as macros incorporadas).

Ehm ... Surpreende-me que ninguém tenha percebido que o compilador simplesmente otimizará o teste e colocará um resultado fixo como valor de retorno. Isso torna todos os exemplos de código acima, efetivamente inúteis. A única coisa que seria retornada é a persistência no tempo de compilação! E sim, testei todos os exemplos acima. Aqui está um exemplo com o 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;
}

Desmontagem

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

Talvez seja possível desativar QUALQUER otimização em tempo de compilação para essa função, mas não sei. Caso contrário, talvez seja possível codificá-lo na montagem, embora isso não seja portátil. E mesmo assim, isso pode ser otimizado. Isso me faz pensar que preciso de um montador realmente ruim, implementar o mesmo código para todas as CPUs / conjuntos de instruções existentes e bem ... não importa.

Além disso, alguém aqui disse que endianness não muda durante o tempo de execução. ERRADO. Existem máquinas bi-endian por aí. Sua endianness pode variar durante a execução. Além disso, não há apenas Little Endian e Big Endian, mas também outras endianidades (que palavra).

Eu odeio e amo codificar ao mesmo tempo ...

Declare uma variável int:

int variable = 0xFF;

Agora use ponteiros char * para várias partes e verifique o que há nessas partes.

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

Dependendo de qual deles aponta para o byte 0xFF, agora é possível detectar endianness. Isso requer sizeof (int)> sizeof (char), mas é definitivamente verdade para as plataformas discutidas.

Para obter mais detalhes, consulte este artigo do projeto de código Conceitos básicos sobre Endianness :

Como testar dinamicamente o tipo Endian em tempo de execução?

Conforme explicado nas Perguntas frequentes sobre animação por computador, você pode usar a seguinte função para verificar se seu código está sendo executado em um sistema Little ou Big Endian: Recolher

#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 atribui o valor 0001h a um número inteiro de 16 bits. Um ponteiro de caractere é então designado para apontar para o primeiro byte (menos significativo) do valor inteiro. Se o primeiro byte do número inteiro for 0x01h, o sistema será Little-Endian (o 0x01h está no endereço mais baixo ou menos significativo). Se for 0x00h, o sistema é Big-Endian.

A maneira C ++ tem sido usar o boost , onde verificações e transmissões do pré-processador são compartimentadas em bibliotecas muito testadas.

A Biblioteca Predef (boost / predef.h) reconhece quatro tipos diferentes de endianness .

A Biblioteca Endian foi planejada para ser submetida ao padrão C ++ e suporta uma ampla variedade de operações em dados sensíveis a endian.

Conforme declarado nas respostas acima, o Endianness fará parte do c ++ 20.

A menos que você esteja usando uma estrutura que foi portada para os processadores PPC e Intel, você terá que fazer compilações condicionais, uma vez que as plataformas PPC e Intel têm arquiteturas de hardware, pipelines, barramentos, etc. completamente diferentes. Isso torna o código de montagem completamente diferente entre os dois.

Quanto à localização de endianness, faça o seguinte:

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

Você obterá que tempChar seja 0x12 ou 0x34, a partir do qual você conhecerá o endianness.

Eu faria algo assim:

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

Nessa linha, você obteria uma função com economia de tempo que faz o cálculo apenas uma vez.

Como mencionado acima, use truques de união.

Porém, existem alguns problemas com os recomendados acima, principalmente o acesso desalinhado à memória é notoriamente lento para a maioria das arquiteturas, e alguns compiladores nem sequer reconhecem tais predicados constantes, a menos que estejam alinhados com as palavras.

Como o mero teste endian é chato, aqui vai a função (modelo) que inverterá a entrada / saída do número inteiro arbitrário de acordo com a sua especificação, independentemente da arquitetura do 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 converter de endian especificado em host, use:

host = endian(source, endian_of_source)

Para converter de host endian para determinado endian, use:

output = endian(hostsource, endian_you_want_to_output)

O código resultante é tão rápido quanto escrever montagem manual no clang, no gcc é um pouco mais lento (desenrolado &, <<, >>, | para cada byte), mas ainda decente.

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

Não use a union!

C ++ não permite punção de tipo via unions!
Ler de um campo de união que não foi o último campo gravado é um comportamento indefinido !
Muitos compiladores suportam isso como extensões, mas o idioma não garante.

Veja esta resposta para mais detalhes:

https://stackoverflow.com/a/11996970

Existem apenas duas respostas válidas que são garantidas como portáteis.

A primeira resposta, se você tiver acesso a um sistema que suporte C ++ 20,
será usar std::endiano <type_traits>cabeçalho.

(No momento em que este artigo foi escrito, o C ++ 20 ainda não foi lançado, mas, a menos que algo afete std::endiana inclusão, essa deve ser a maneira preferida de testar o endianness no tempo de compilação a partir do C ++ 20).

C ++ 20 em diante

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

Antes do C ++ 20, a única resposta válida é armazenar um número inteiro e, em seguida, inspecionar seu primeiro byte por meio de punção de tipo.
Diferentemente do uso de unions, isso é expressamente permitido pelo sistema de tipos do C ++.

Também é importante lembrar que a portabilidade ideal static_castdeve ser usada,
porque a reinterpret_castimplementação está definida.

Se um programa tentar acessar o valor armazenado de um objeto por meio de um valor gl gl diferente de um dos seguintes tipos, o comportamento será indefinido: ... a charou unsigned chartype.

C ++ 11 em diante

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 em diante (sem enumeração)

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");

Essa é outra solução. Semelhante à solução de Andrew Hare.

não testado, mas na minha opinião, isso deve funcionar? porque será 0x01 no little endian e 0x00 no big endian?

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

Declarar:

Minha postagem inicial foi declarada incorretamente como "tempo de compilação". Não é, é até impossível no padrão C ++ atual. O constexpr NÃO significa que a função sempre faz computação em tempo de compilação. Obrigado Richard Hodges pela correção.

tempo de compilação, não macro, solução constexpr C ++ 11:

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

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

Você também pode fazer isso através do pré-processador usando algo como o arquivo de cabeçalho boost, que pode ser encontrado boost endian

A menos que o cabeçalho endian seja somente GCC, ele fornece macros que você pode 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!");
...

Se você não deseja compilação condicional, basta escrever código independente endian. Aqui está um exemplo (retirado de Rob Pike ):

Lendo um número inteiro armazenado no little-endian no disco, de uma maneira independente do endian:

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

O mesmo código, tentando levar em consideração a resistência da 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;

Que tal agora?

#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;
}

Aqui está outra versão em C. Ele define uma macro chamada wicked_cast()punição de tipo em linha via literais de união C99 e o __typeof__operador não padrão .

#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);
}

Se números inteiros são valores de byte único, endianness não faz sentido e um erro em tempo de compilação será gerado.

A maneira como os compiladores C (pelo menos todos os que eu conheço) funcionam no endianness deve ser decidida no momento da compilação. Mesmo para processadores diabéticos (como o ARM e o MIPS), é necessário escolher a endianness no momento da compilação. Além disso, a endianness é definida em todos os formatos de arquivo comuns para executáveis ​​(como ELF). Embora seja possível criar um blob binário de código biandiano (para alguma exploração do servidor ARM, talvez?), Provavelmente isso deve ser feito em assembly.

Como apontado pelo Coriiander, a maioria (senão todos) desses códigos aqui será otimizada no tempo de compilação, para que os binários gerados não verifiquem a "continuidade" no tempo de execução.

Foi observado que um determinado executável não deve ser executado em duas ordens de bytes diferentes, mas não tenho idéia se esse é sempre o caso, e parece um hack para mim verificar no momento da compilação. Então eu codifiquei esta função:

#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;
}

O MinGW não conseguiu otimizar esse código, apesar de otimizar os outros códigos daqui. Eu acredito que é porque deixo o valor "aleatório" que foi alocado na memória de bytes menores como era (pelo menos 7 de seus bits), para que o compilador não possa saber qual é esse valor aleatório e não otimiza a função ausente.

Também codifiquei a função para que a verificação seja realizada apenas uma vez e o valor de retorno seja armazenado para os próximos testes.

embora não exista uma maneira rápida e padrão de determiná-lo, isso resultará em:

#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; 
} 

Veja Ilustração Endianness - Código de Nível C.

// 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;
} 

Eu estava examinando o livro: Sistema de Computadores: a perspectiva de um programador , e há um problema para determinar qual endian é esse no programa C.

Eu usei o recurso do ponteiro para fazer isso da seguinte maneira:

#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 o int ocupa 4 bytes, e char ocupa apenas 1 bytes. Poderíamos usar um ponteiro char para apontar para int com o valor 1. Portanto, se o computador é pouco endian, o char para o qual o apontador char aponta é com valor 1, caso contrário, seu valor deve ser 0.