C Definisi makro untuk menentukan mesin big endian atau little endian?

Apakah ada definisi makro satu baris untuk menentukan endianness mesin. Saya menggunakan kode berikut tetapi mengubahnya menjadi makro akan terlalu lama.

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

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

Kode yang mendukung urutan byte arbitrer, siap untuk dimasukkan ke dalam file bernama 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

Anda akan memeriksa sistem little endian melalui

O32_HOST_ORDER == O32_LITTLE_ENDIAN

Jika Anda memiliki kompiler yang mendukung literal majemuk C99:

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

atau:

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

Secara umum, Anda harus mencoba menulis kode yang tidak bergantung pada endianness platform host.

Contoh implementasi host-endianness-independent dari 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];
}

Tidak ada standar, tetapi pada banyak sistem termasuk <endian.h>akan memberi Anda beberapa definisi untuk dicari.

Untuk mendeteksi endianness pada waktu proses, Anda harus dapat merujuk ke memori. Jika Anda tetap menggunakan C standar, mendeklarasikan variabel dalam memori memerlukan pernyataan, tetapi mengembalikan nilai memerlukan ekspresi. Saya tidak tahu cara melakukan ini dalam satu makro — inilah alasan gcc memiliki ekstensi :-)

Jika Anda ingin memiliki file .h, Anda dapat menentukan

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

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

lalu Anda bisa menggunakan ENDIANNESSmakro sesuka Anda.

Jika Anda hanya ingin mengandalkan preprocessor, Anda harus mencari tahu daftar simbol yang telah ditentukan sebelumnya. Aritmatika preprocessor tidak memiliki konsep pengalamatan.

GCC di Mac mendefinisikan __LITTLE_ENDIAN__atau__BIG_ENDIAN__

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

Kemudian, Anda dapat menambahkan lebih banyak arahan bersyarat praprosesor berdasarkan deteksi platform seperti #ifdef _WIN32dll.

Saya yakin inilah yang diminta. Saya hanya menguji ini pada mesin endian kecil di bawah pnidui. Seseorang mohon konfirmasi pada mesin big endian.

    #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

Sebagai catatan tambahan (khusus kompilator), dengan kompilator agresif Anda dapat menggunakan pengoptimalan "penghapusan kode mati" untuk mencapai efek yang sama seperti waktu kompilasi #ifseperti ini:

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

Hal di atas bergantung pada fakta bahwa kompilator mengenali nilai konstan pada waktu kompilasi, sepenuhnya menghapus kode di dalamnya if (false) { ... }dan mengganti kode seperti if (true) { foo(); }dengan foo();skenario kasus terburuk: kompilator tidak melakukan pengoptimalan, Anda masih mendapatkan kode yang benar tetapi sedikit lebih lambat.

Jika Anda mencari tes waktu kompilasi dan Anda menggunakan gcc, Anda dapat melakukan:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

Lihat dokumentasi gcc untuk informasi lebih lanjut.

Anda dapat di akses fakta memori dari objek sementara dengan menggunakan literal senyawa (C99):

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

GCC mana yang akan dievaluasi pada waktu kompilasi.

'Perpustakaan jaringan C' menawarkan fungsi untuk menangani ketangguhan. Yaitu htons (), htonl (), ntohs () dan ntohl () ... di mana n adalah "jaringan" (mis. Big-endian) dan h adalah "host" (yaitu kesempurnaan mesin yang menjalankan kode).

'Fungsi' yang jelas ini (umumnya) didefinisikan sebagai makro [lihat <netinet / in.h>], jadi tidak ada overhead waktu proses untuk menggunakannya.

Makro berikut menggunakan 'fungsi' ini untuk mengevaluasi ketangguhan.

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

Sebagai tambahan:

Satu-satunya saat saya perlu mengetahui endian'ness dari suatu sistem adalah ketika saya menulis variabel [ke file / lainnya] yang dapat dibaca oleh sistem lain yang tidak diketahui endian'ness (untuk kompatibilitas lintas platform ) ... Dalam kasus seperti ini, Anda mungkin lebih suka menggunakan fungsi endian secara langsung:

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

Gunakan fungsi sebaris daripada makro. Selain itu, Anda perlu menyimpan sesuatu dalam memori yang merupakan efek samping makro yang tidak terlalu bagus.

Anda bisa mengubahnya menjadi makro pendek menggunakan variabel statis atau global, seperti ini:

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

Meskipun tidak ada #define portabel atau sesuatu yang dapat diandalkan, platform menyediakan fungsi standar untuk mengonversi ke dan dari endian 'host' Anda.

Umumnya, Anda melakukan penyimpanan - ke disk, atau jaringan - menggunakan 'network endian', yang merupakan BIG endian, dan komputasi lokal menggunakan host endian (yang pada x86 disebut LITTLE endian). Anda menggunakan htons()dan ntohs()dan teman untuk mengonversi di antara keduanya.

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

Jangan lupa bahwa kesungguhan bukanlah keseluruhan cerita - ukuran charmungkin bukan 8 bit (mis. DSP), negasi pelengkap dua tidak dijamin (mis. Cray), penyelarasan ketat mungkin diperlukan (mis. SPARC, juga ARM muncul di tengah -endian saat tidak sejajar), dll, dll.

Mungkin ide yang lebih baik untuk menargetkan arsitektur CPU tertentu sebagai gantinya.

Sebagai contoh:

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

Perhatikan bahwa solusi ini juga sayangnya tidak ultra-portabel, karena bergantung pada definisi khusus kompiler (tidak ada standar, tetapi berikut adalah kompilasi bagus dari definisi tersebut).

Coba ini:

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

   TEST;
}

Harap perhatikan bahwa sebagian besar jawaban di sini tidak portabel, karena penyusun hari ini akan mengevaluasi jawaban tersebut dalam waktu kompilasi (bergantung pada pengoptimalan) dan mengembalikan nilai tertentu berdasarkan endian tertentu, sedangkan endian mesin yang sebenarnya dapat berbeda. Nilai di mana endianness diuji, tidak akan pernah mencapai memori sistem sehingga kode yang dijalankan sebenarnya akan mengembalikan hasil yang sama terlepas dari endian yang sebenarnya.

untuk contoh , di ARM Cortex-M3 endianness diimplementasikan akan mencerminkan dalam AIRCR.ENDIANNESS Status bit dan compiler tidak dapat mengetahui nilai ini dalam waktu kompilasi.

Hasil kompilasi untuk beberapa jawaban yang disarankan di sini:

https://godbolt.org/z/GJGNE2 untuk jawaban ini ,

https://godbolt.org/z/Yv-pyJ untuk ini jawaban , dan seterusnya.

Untuk mengatasinya, Anda harus menggunakan volatilekualifikasi. Yogeesh H TJawabannya 's adalah yang paling dekat untuk penggunaan kehidupan nyata saat ini, tapi karena Christophmenyarankan solusi yang lebih komprehensif, memperbaiki sedikit untuk itu jawabannya akan membuat jawabannya lengkap, hanya menambahkan volatileuntuk deklarasi union: static const volatile union.

Ini akan memastikan penyimpanan dan pembacaan dari memori, yang diperlukan untuk menentukan ketangguhan.

Jika Anda membuang preprocessor #defines

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

Anda biasanya dapat menemukan hal-hal yang akan membantu Anda. Dengan logika waktu kompilasi.

#define __LITTLE_ENDIAN__ 1
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

Namun, berbagai kompiler mungkin memiliki definisi yang berbeda.

Jawaban saya tidak seperti yang ditanyakan tetapi sangat mudah untuk mengetahui apakah sistem Anda little endian atau big endian?

Kode:

#include<stdio.h>

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

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

Kode C untuk memeriksa apakah suatu sistem adalah little-endian atau big-indian.

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

Makro untuk menemukan endiannes

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

atau

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