Apakah ada cara terprogram untuk mendeteksi apakah Anda menggunakan arsitektur big-endian atau little-endian? Saya harus dapat menulis kode yang akan dijalankan pada sistem Intel atau PPC dan menggunakan kode yang persis sama (yaitu tidak ada kompilasi bersyarat).

Saya tidak suka metode ini berdasarkan tipe punning - sering akan diperingatkan oleh kompiler. Persis seperti itulah serikat pekerja!

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

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

Prinsipnya setara dengan jenis huruf seperti yang disarankan oleh orang lain, tetapi ini lebih jelas - dan menurut C99, dijamin benar. gcc lebih suka ini dibandingkan dengan penunjuk penunjuk langsung.

Ini juga jauh lebih baik daripada memperbaiki endianness pada waktu kompilasi - untuk OS yang mendukung multi-arsitektur (misalnya binary pada Mac os x), ini akan bekerja untuk ppc / i386, sedangkan sangat mudah untuk mengacaukan semuanya jika tidak .

Anda dapat melakukannya dengan menetapkan int dan menutup bit, tetapi mungkin cara termudah adalah dengan menggunakan ops konversi byte yang dibangun di dalam jaringan (karena pesanan byte jaringan selalu merupakan big endian).

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

Mengotak-atik sedikit bisa lebih cepat, tetapi cara ini sederhana, mudah dan sangat tidak mungkin untuk dikacaukan.

Silakan lihat artikel ini :

Berikut ini beberapa kode untuk menentukan jenis mesin Anda

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

Anda dapat menggunakan std::endianjika Anda memiliki akses ke kompiler C ++ 20 seperti GCC 8+ atau Clang 7+.

Catatan: std::endianmulai <type_traits>tetapi dipindahkan ke <bit>pada 2019 pertemuan Cologne. GCC 8, Dentang 7, 8 dan 9 memilikinya <type_traits>sedangkan GCC 9+ dan Dentang 10+ memilikinya <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
}

Ini biasanya dilakukan pada waktu kompilasi (khusus untuk alasan kinerja) dengan menggunakan file header yang tersedia dari kompiler atau buat sendiri. Di linux Anda memiliki file header "/usr/include/endian.h"

Saya terkejut tidak ada yang menyebutkan macro yang didefinisikan oleh pre-processor secara default. Meskipun ini akan bervariasi tergantung pada platform Anda; mereka jauh lebih bersih daripada harus menulis cek-endian Anda sendiri.

Sebagai contoh; jika kita melihat makro bawaan yang didefinisikan GCC (pada mesin X86-64):

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

Pada mesin PPC saya mendapatkan:

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

( :| gcc -dM -E -x c -Keajaiban mencetak semua makro built-in).

Ehm ... Ini mengejutkan saya bahwa tidak ada yang menyadari bahwa kompiler hanya akan mengoptimalkan tes, dan akan memberikan hasil yang tetap sebagai nilai pengembalian. Ini membuat semua contoh kode di atas, tidak berguna secara efektif. Satu-satunya hal yang akan dikembalikan adalah endianness pada waktu kompilasi! Dan ya, saya menguji semua contoh di atas. Berikut ini adalah contoh dengan MSVC 9.0 (Visual Studio 2008).

Kode C murni

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

Membongkar

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

Mungkin dimungkinkan untuk mematikan optimasi waktu kompilasi APAPUN hanya untuk fungsi ini, tapi saya tidak tahu. Kalau tidak, itu mungkin untuk hardcode dalam perakitan, meskipun itu tidak portabel. Dan bahkan itu pun mungkin akan dioptimalkan. Itu membuat saya berpikir saya perlu assembler yang benar-benar jelek, mengimplementasikan kode yang sama untuk semua set CPU / instruksi yang ada, dan juga .... sudahlah.

Juga, seseorang di sini mengatakan bahwa endianness tidak berubah selama run-time. SALAH. Ada mesin bi-endian di luar sana. Endianness mereka dapat bervariasi eksekusi durng. JUGA, tidak hanya Little Endian dan Big Endian, tetapi juga endiannesses lain (kata apa).

Saya benci dan suka coding pada saat yang sama ...

Deklarasikan variabel int:

int variable = 0xFF;

Sekarang gunakan pointer * char ke berbagai bagian dan periksa apa yang ada di bagian-bagian itu.

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

Tergantung pada yang menunjuk ke 0xFF byte sekarang Anda dapat mendeteksi endianness. Ini membutuhkan sizeof (int)> sizeof (char), tapi itu pasti benar untuk platform yang dibahas.

Untuk perincian lebih lanjut, Anda mungkin ingin memeriksa artikel proyek ini Konsep dasar tentang Endianness :

Bagaimana cara menguji tipe Endian secara dinamis saat run time?

Seperti yang dijelaskan dalam FAQ Animasi Komputer, Anda dapat menggunakan fungsi berikut untuk melihat apakah kode Anda berjalan pada sistem Little-atau Big-Endian: Collapse

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

Kode ini memberikan nilai 0001h ke integer 16-bit. Pointer char kemudian ditugaskan untuk menunjuk pada byte pertama (paling tidak signifikan) dari nilai integer. Jika byte pertama dari integer adalah 0x01h, maka sistemnya adalah Little-Endian (0x01h berada di alamat terendah, atau paling tidak signifikan). Jika 0x00j maka sistemnya adalah Big-Endian.

Cara C ++ adalah menggunakan boost , di mana pengecekan dan cetakan preprosesor terkotak di dalam perpustakaan yang sangat teruji.

Perpustakaan Predef (boost / predef.h) mengenali empat jenis endianness .

The Endian Perpustakaan direncanakan untuk diserahkan ke standar C ++, dan mendukung berbagai operasi pada data endian-sensitif.

Seperti yang dinyatakan dalam jawaban di atas, Endianness akan menjadi bagian dari c ++ 20.

Kecuali jika Anda menggunakan kerangka kerja yang telah porting ke PPC dan prosesor Intel, Anda harus melakukan kompilasi bersyarat, karena PPC dan platform Intel memiliki arsitektur perangkat keras yang berbeda, jalur pipa, bus, dll. Ini membuat kode perakitan benar-benar berbeda antara keduanya

Sedangkan untuk menemukan endianness, lakukan hal berikut:

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

Anda akan mendapatkan tempChar menjadi 0x12 atau 0x34, dari mana Anda akan mengetahui endianness.

Saya akan melakukan sesuatu seperti ini:

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

Seiring garis ini, Anda akan mendapatkan fungsi efisien waktu yang hanya melakukan perhitungan sekali.

Seperti yang dinyatakan di atas, gunakan trik penyatuan.

Ada beberapa masalah dengan yang disarankan di atas, terutama bahwa akses memori yang tidak selaras sangat lambat untuk sebagian besar arsitektur, dan beberapa kompiler bahkan tidak akan mengenali predikat konstan seperti itu sama sekali, kecuali jika kata disejajarkan.

Karena hanya tes endian yang membosankan, inilah fungsi (templat) yang akan membalik input / output integer sewenang-wenang menurut spesifikasi Anda, terlepas dari arsitektur 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;
};

Pemakaian:

Untuk mengkonversi dari endian yang diberikan ke host, gunakan:

host = endian(source, endian_of_source)

Untuk mengonversi dari host endian ke endian yang diberikan, gunakan:

output = endian(hostsource, endian_you_want_to_output)

Kode yang dihasilkan adalah secepat menulis perakitan tangan di dentang, pada gcc itu sedikit lebih lambat (belum dibuka &, <<, >>, | untuk setiap byte) tetapi masih layak.

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

Jangan gunakan a union !

C ++ tidak mengizinkan jenis hukuman via unions!
Membaca dari bidang persatuan yang bukan bidang terakhir yang ditulis untuk adalah perilaku yang tidak terdefinisi !
Banyak kompiler mendukungnya sebagai ekstensi, tetapi bahasa tidak memberikan jaminan.

Lihat jawaban ini untuk lebih jelasnya:

https://stackoverflow.com/a/11996970

Hanya ada dua jawaban valid yang dijamin portabel.

Jawaban pertama, jika Anda memiliki akses ke sistem yang mendukung C ++ 20,
adalah menggunakan std::endiandari <type_traits>header.

(Pada saat penulisan, C ++ 20 belum dirilis, tetapi kecuali ada sesuatu yang mempengaruhi std::endian inklusi, ini akan menjadi cara yang disukai untuk menguji endianness pada waktu kompilasi dari C ++ 20 dan seterusnya.)

C ++ 20 Selanjutnya

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

Sebelum C ++ 20, satu-satunya jawaban yang valid adalah untuk menyimpan integer dan kemudian memeriksa byte pertamanya melalui jenis hukuman.
Berbeda dengan penggunaanunion s, ini diizinkan oleh sistem tipe C ++.

Penting juga untuk diingat bahwa untuk portabilitas optimal static_castharus digunakan,
karena reinterpret_castimplementasi didefinisikan.

Jika suatu program mencoba untuk mengakses nilai yang tersimpan dari suatu objek melalui nilai lain selain salah satu dari jenis berikut perilaku tidak terdefinisi: ... a charatau unsigned charketik.

C ++ 11 Selanjutnya

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 Selanjutnya (tanpa enum)

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

Ini solusi lain. Mirip dengan solusi Andrew Hare.

belum diuji, tetapi dalam pikiran saya, ini harus bekerja? karena itu akan menjadi 0x01 pada little endian, dan 0x00 pada big endian?

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

Menyatakan:

Posting awal saya salah dinyatakan sebagai "waktu kompilasi". Bukan, itu bahkan tidak mungkin dalam standar C ++ saat ini. Constexpr TIDAK berarti fungsi selalu melakukan perhitungan waktu kompilasi. Terima kasih Richard Hodges untuk koreksi.

waktu kompilasi, solusi constexpr non-makro, C ++ 11:

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

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

Anda juga dapat melakukan ini melalui preprocessor menggunakan sesuatu seperti boost file header yang dapat ditemukan boost endian

Kecuali jika header endian hanya GCC, ia menyediakan makro yang dapat Anda gunakan.

#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!");
...

Jika Anda tidak ingin kompilasi bersyarat, Anda bisa menulis kode independen endian. Berikut ini sebuah contoh (diambil dari Rob Pike ):

Membaca integer yang disimpan dalam little-endian pada disk, dengan cara endian independen:

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

Kode yang sama, mencoba memperhitungkan endianness mesin:

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;

Bagaimana dengan ini?

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

Ini versi C lainnya. Ini mendefinisikan makro yang disebut wicked_cast()untuk inline type punning via C99 union literals dan __typeof__operator non-standar .

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

Jika bilangan bulat adalah nilai byte tunggal, endianness tidak masuk akal dan kesalahan waktu kompilasi akan dihasilkan.

Cara C compiler (setidaknya semua orang yang saya tahu) bekerja endianness yang telah diputuskan pada waktu kompilasi. Bahkan untuk prosesor biendian (seperti ARM dan MIPS) Anda harus memilih endianness pada waktu kompilasi. Lebih jauh lagi endianness didefinisikan dalam semua format file umum untuk executable (seperti ELF). Meskipun dimungkinkan untuk membuat gumpalan kode biandian biner (untuk beberapa eksploitasi server ARM mungkin?) Mungkin harus dilakukan dalam perakitan.

Seperti yang ditunjukkan oleh Coriiander, sebagian besar (jika tidak semua) dari kode-kode di sini akan dioptimalkan pada saat kompilasi, sehingga binari yang dihasilkan tidak akan memeriksa "endianness" pada saat run time.

Telah diamati bahwa executable yang diberikan tidak boleh berjalan dalam dua byte perintah yang berbeda, tetapi saya tidak tahu apakah itu selalu terjadi, dan sepertinya hack bagi saya memeriksa pada waktu kompilasi. Jadi saya memberi kode fungsi ini:

#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 tidak dapat mengoptimalkan kode ini, meskipun ia mengoptimalkan kode lain di sini. Saya percaya itu karena saya meninggalkan nilai "acak" yang dialokasikan pada memori byte yang lebih kecil seperti sebelumnya (setidaknya 7 bitnya), sehingga kompiler tidak dapat mengetahui apa nilai acak itu dan tidak mengoptimalkan fungsi pergi.

Saya juga memberi kode fungsi sehingga pemeriksaan hanya dilakukan sekali, dan nilai pengembalian disimpan untuk pengujian berikutnya.

sementara tidak ada cara cepat dan standar untuk menentukannya, ini akan menampilkannya:

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

Lihat ilustrasi Endianness - C-Level Code.

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

Saya membaca buku pelajaran: Sistem Komputer: perspektif seorang programmer , dan ada masalah untuk menentukan endian mana yang menggunakan program C.

Saya menggunakan fitur pointer untuk melakukan itu sebagai berikut:

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

Karena int membutuhkan 4 byte, dan char hanya membutuhkan 1 byte. Kita bisa menggunakan pointer char untuk menunjuk ke int dengan nilai 1. Jadi jika komputer sedikit endian, char yang menunjuk pointer char adalah dengan nilai 1, jika tidak, nilainya harus 0.