C Büyük endian veya küçük endian makineyi belirlemek için makro tanım?

Makinenin dayanıklılığını belirlemek için tek satırlık bir makro tanımı var mı? Aşağıdaki kodu kullanıyorum ancak makroya dönüştürmek çok uzun olacaktır.

unsigned char test_endian( void )
{
    int test_var = 1;
    unsigned char *test_endian = (unsigned char*)&test_var;

    return (test_endian[0] == 0);
}

Rasgele bayt siparişlerini destekleyen kod, şu adla adlandırılan bir dosyaya konulmaya hazır order32.h:

#ifndef ORDER32_H
#define ORDER32_H

#include <limits.h>
#include <stdint.h>

#if CHAR_BIT != 8
#error "unsupported char size"
#endif

enum
{
    O32_LITTLE_ENDIAN = 0x03020100ul,
    O32_BIG_ENDIAN = 0x00010203ul,
    O32_PDP_ENDIAN = 0x01000302ul,      /* DEC PDP-11 (aka ENDIAN_LITTLE_WORD) */
    O32_HONEYWELL_ENDIAN = 0x02030001ul /* Honeywell 316 (aka ENDIAN_BIG_WORD) */
};

static const union { unsigned char bytes[4]; uint32_t value; } o32_host_order =
    { { 0, 1, 2, 3 } };

#define O32_HOST_ORDER (o32_host_order.value)

#endif

Küçük endian sistemlerini şu yolla kontrol edersiniz:

O32_HOST_ORDER == O32_LITTLE_ENDIAN

C99 bileşik değişmez değerlerini destekleyen bir derleyiciniz varsa:

#define IS_BIG_ENDIAN (!*(unsigned char *)&(uint16_t){1})

veya:

#define IS_BIG_ENDIAN (!(union { uint16_t u16; unsigned char c; }){ .u16 = 1 }.c)

Genel olarak, ana bilgisayar platformunun sonluluğuna bağlı olmayan bir kod yazmaya çalışmalısınız.

Aşağıdakilerin ana bilgisayar-endianness-bağımsız uygulama örneği ntohl():

uint32_t ntohl(uint32_t n)
{
    unsigned char *np = (unsigned char *)&n;

    return ((uint32_t)np[0] << 24) |
        ((uint32_t)np[1] << 16) |
        ((uint32_t)np[2] << 8) |
        (uint32_t)np[3];
}

Bir standart yoktur, ancak dahil olmak üzere birçok sistemde <endian.h>aramanız için bazı tanımlar verir.

Çalışma zamanında sonu algılamak için, belleğe başvurmanız gerekir. Standart C'ye sadık kalırsanız, bellekte bir değişken bildirmek bir ifade gerektirir, ancak bir değer döndürmek bir ifade gerektirir. Bunu tek bir makroda nasıl yapacağımı bilmiyorum — bu nedenle gcc'nin uzantıları vardır :-)

Bir .h dosyasına sahip olmak istiyorsanız,

static uint32_t endianness = 0xdeadbeef; 
enum endianness { BIG, LITTLE };

#define ENDIANNESS ( *(const char *)&endianness == 0xef ? LITTLE \
                   : *(const char *)&endianness == 0xde ? BIG \
                   : assert(0))

ve sonra ENDIANNESSmakroyu istediğiniz gibi kullanabilirsiniz .

Yalnızca ön işlemciye güvenmek istiyorsanız, önceden tanımlanmış sembollerin listesini bulmanız gerekir. Önişlemci aritmetiği, adresleme kavramına sahip değildir.

Mac'te GCC , __LITTLE_ENDIAN__veya__BIG_ENDIAN__

$ gcc -E -dM - < /dev/null |grep ENDIAN
#define __LITTLE_ENDIAN__ 1

Ardından, platform algılamaya dayalı daha fazla önişlemci koşullu yönergesi ekleyebilirsiniz #ifdef _WIN32.

Sanırım bunun istendiğine inanıyorum. Bunu yalnızca msvc altında küçük bir endian makinesinde test ettim. Birisi büyük bir endian makinesinde onayladı.

    #define LITTLE_ENDIAN 0x41424344UL 
    #define BIG_ENDIAN    0x44434241UL
    #define PDP_ENDIAN    0x42414443UL
    #define ENDIAN_ORDER  ('ABCD') 

    #if ENDIAN_ORDER==LITTLE_ENDIAN
        #error "machine is little endian"
    #elif ENDIAN_ORDER==BIG_ENDIAN
        #error "machine is big endian"
    #elif ENDIAN_ORDER==PDP_ENDIAN
        #error "jeez, machine is PDP!"
    #else
        #error "What kind of hardware is this?!"
    #endif

Bir yan not olarak (derleyiciye özel), agresif bir derleyici ile "ölü kod eleme" optimizasyonunu aşağıdaki gibi bir derleme zamanıyla aynı etkiyi elde etmek için kullanabilirsiniz #if:

    unsigned yourOwnEndianSpecific_htonl(unsigned n)
    {
        static unsigned long signature= 0x01020304UL; 
        if (1 == (unsigned char&)signature) // big endian
            return n;
        if (2 == (unsigned char&)signature) // the PDP style
        {
            n = ((n << 8) & 0xFF00FF00UL) | ((n>>8) & 0x00FF00FFUL);
            return n;
        }
        if (4 == (unsigned char&)signature) // little endian
        {
            n = (n << 16) | (n >> 16);
            n = ((n << 8) & 0xFF00FF00UL) | ((n>>8) & 0x00FF00FFUL);
            return n;
        }
        // only weird machines get here
        return n; // ?
    }

Yukarıdaki tamamen içinde kod kaldırır, derleyici derleme zamanında sabit değerler tanır gerçeğine dayanır if (false) { ... }ve benzeri cümledeki kodu if (true) { foo(); }ile foo();kötü durum senaryosu: optimizasyon yapmaz derleyici, yine biraz daha yavaş doğru kodu ama olsun.

Derleme zamanı testi arıyorsanız ve gcc kullanıyorsanız, şunları yapabilirsiniz:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

Daha fazla bilgi için gcc belgelerine bakın .

Sen can aslında erişimde bir bileşik değişmezi (C99) kullanarak geçici nesnenin hafıza:

#define IS_LITTLE_ENDIAN (1 == *(unsigned char *)&(const int){1})

Hangi GCC derleme zamanında değerlendirecektir.

'C ağ kitaplığı', sonsuzluğun üstesinden gelmek için işlevler sunar. Yani htons (), htonl (), ntohs () ve ntohl () ... burada n "ağ" (yani, big-endian) ve h "host" (yani, çalıştıran makinenin endianlığı) kodu).

Bu görünen 'işlevler' (genellikle) makrolar olarak tanımlanır [bkz. <Netinet / in.h>], bu nedenle bunları kullanmak için çalışma zamanı yükü yoktur.

Aşağıdaki makrolar, sonsuzluğu değerlendirmek için bu 'işlevleri' kullanır.

#include <arpa/inet.h>
#define  IS_BIG_ENDIAN     (1 == htons(1))
#define  IS_LITTLE_ENDIAN  (!IS_BIG_ENDIAN)

Ek olarak:

Bir sistemin sonunu bilmem gereken tek zaman, sonu bilinmeyen başka bir sistem tarafından okunabilecek bir değişkeni [bir dosyaya / diğerine] yazdığım zamandır (platformlar arası uyumluluk için) ) ... Bu gibi durumlarda, endian işlevlerini doğrudan kullanmayı tercih edebilirsiniz:

#include <arpa/inet.h>

#define JPEG_MAGIC  (('J'<<24) | ('F'<<16) | ('I'<<8) | 'F')

// Result will be in 'host' byte-order
unsigned long  jpeg_magic = JPEG_MAGIC;

// Result will be in 'network' byte-order (IE. Big-Endian/Human-Readable)
unsigned long  jpeg_magic = htonl(JPEG_MAGIC);

Bir makro yerine bir satır içi işlev kullanın. Ayrıca, bir makronun pek de hoş olmayan bir yan etkisi olan bir şeyi hafızaya kaydetmeniz gerekir.

Şunun gibi statik veya global bir değişken kullanarak onu kısa bir makroya dönüştürebilirsiniz:

static int s_endianess = 0;
#define ENDIANESS() ((s_endianess = 1), (*(unsigned char*) &s_endianess) == 0)

Taşınabilir bir #define veya güvenilecek bir şey olmasa da, platformlar 'ana bilgisayar' endianınıza ve 'ana bilgisayar' endianınıza dönüştürme için standart işlevler sağlar.

Genellikle, depolama - diske veya ağa - BÜYÜK endian olan 'ağ endian'ı' ve ana bilgisayar endian'ı ( x86'da LITTLE endian olan) kullanarak yerel hesaplama yaparsınız . Sen kullanmak htons()ve ntohs()ve arkadaşlar ikisi arasında dönüştürmek için.

#include <stdint.h>
#define IS_LITTLE_ENDIAN (*(uint16_t*)"\0\1">>8)
#define IS_BIG_ENDIAN (*(uint16_t*)"\1\0">>8)

O endianness'ın unutma bütün hikaye değil - büyüklüğü charkudretini 8 bit ikiye tümleme olumsuzluk sıkı hizalama gerekebilir, (mesela Cray) garanti edilmemektedir (DSP en örn) (örn SPARC, ayrıca içine yaylar ARM olamaz ortada - hizalanmadığında endian ), vb.

Bunun yerine belirli bir CPU mimarisini hedeflemek daha iyi bir fikir olabilir .

Örneğin:

#if defined(__i386__) || defined(_M_IX86) || defined(_M_IX64)
  #define USE_LITTLE_ENDIAN_IMPL
#endif

void my_func()
{
#ifdef USE_LITTLE_ENDIAN_IMPL
  // Intel x86-optimized, LE implementation
#else
  // slow but safe implementation
#endif
}

Derleyiciye özgü tanımlara bağlı olduğu için bu çözümün maalesef ultra taşınabilir olmadığını da unutmayın (standart yoktur, ancak işte bu tür tanımların güzel bir derlemesi).

Bunu dene:

#include<stdio.h>        
int x=1;
#define TEST (*(char*)&(x)==1)?printf("little endian"):printf("Big endian")
int main()
{

   TEST;
}

Lütfen buradaki yanıtların çoğunun taşınabilir olmadığına dikkat edin, çünkü bugün derleyiciler bu yanıtları derleme zamanında değerlendirecek (optimizasyona bağlıdır) ve gerçek makine dayanıklılığı farklı olabilirken belirli bir süreye göre belirli bir değer döndürecektir. Sonuculuğun test edildiği değerler asla sistem belleğine ulaşmayacaktır, bu nedenle gerçek yürütülen kod, gerçek sonsuzluktan bağımsız olarak aynı sonucu döndürecektir.

İçin örneğin , ARM Cortex-M3 uygulanan endian bir durum biti AIRCR.ENDIANNESS içinde yansıtacaktır ve derleyici derleme zamanında bu değeri bilemez.

Burada önerilen yanıtlardan bazıları için derleme çıktısı:

Bu cevap için https://godbolt.org/z/GJGNE2 ,

https://godbolt.org/z/Yv-pyJ için bu yanıt vb.

Bunu çözmek için volatileniteleyiciyi kullanmanız gerekecek . Yogeesh H Tbireyin cevabı bugünün gerçek hayat kullanımı için en yakın biridir, ancak o zamandan beri Christophdaha kapsamlı bir çözüm önerir, onun için hafif bir düzeltme cevap cevap eksiksiz, sadece eklemek yapacak volatilesendika bildirisine: static const volatile union.

Bu, kalıcılığı belirlemek için gerekli olan hafızadan depolamayı ve okumayı garanti eder.

Ön işlemciyi dökerseniz #defines

gcc -dM -E - < /dev/null
g++ -dM -E -x c++ - < /dev/null

Genellikle sana yardımcı olacak şeyler bulabilirsin. Derleme zamanı mantığı ile.

#define __LITTLE_ENDIAN__ 1
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

Bununla birlikte, çeşitli derleyicilerin farklı tanımları olabilir.

Cevabım sorulduğu gibi değil ama sisteminizin küçük endian mı yoksa büyük endian mı olduğunu bulmak gerçekten basit mi?

Kod:

#include<stdio.h>

int main()
{
  int a = 1;
  char *b;

  b = (char *)&a;
  if (*b)
    printf("Little Endian\n");
  else
    printf("Big Endian\n");
}

C Bir sistemin küçük yerli mi yoksa büyük Hintli mi olduğunu kontrol etmek için kod.

int i = 7;
char* pc = (char*)(&i);
if (pc[0] == '\x7') // aliasing through char is ok
    puts("This system is little-endian");
else
    puts("This system is big-endian");

Endiannes bulmak için makro

#define ENDIANNES() ((1 && 1 == 0) ? printf("Big-Endian"):printf("Little-Endian"))

veya

#include <stdio.h>

#define ENDIAN() { \
volatile unsigned long ul = 1;\
volatile unsigned char *p;\
p = (volatile unsigned char *)&ul;\
if (*p == 1)\
puts("Little endian.");\
else if (*(p+(sizeof(unsigned long)-1)) == 1)\
puts("Big endian.");\
else puts("Unknown endian.");\
}

int main(void) 
{
       ENDIAN();
       return 0;
}