C Визначення макросу для визначення великої ендіанської або малої ендіанській машини?

Чи є макрозначення одного рядка для визначення витривалості машини. Я використовую наступний код, але перетворення його в макрос буде занадто довгим.

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

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

Код, що підтримує довільні байтні замовлення, готовий до введення у файл, який називається 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

Ви б перевірили, чи мало ендіанських систем через

O32_HOST_ORDER == O32_LITTLE_ENDIAN

Якщо у вас є компілятор, який підтримує складні літерали C99:

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

або:

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

Взагалі, вам слід спробувати написати код, який не залежить від витримки хост-платформи.

Приклад реалізації незалежної від хост-ендіансів 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];
}

Немає стандарту, але для багатьох систем, в тому числі, <endian.h>ви дасте кілька визначень, на які потрібно звернути увагу.

Щоб виявити витривалість під час виконання, ви повинні мати можливість посилатися на пам'ять. Якщо ви дотримуєтесь стандартного C, для декларування змінної в пам'яті потрібний оператор, але для повернення значення потрібно вираження. Я не знаю, як це зробити в одному макросі - ось чому gcc має розширення :-)

Якщо ви бажаєте мати .h файл, ви можете визначитись

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

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

і тоді ви можете використовувати ENDIANNESSмакрос як хочете.

Якщо ви хочете покластися лише на препроцесора, вам доведеться розібратися у списку попередньо визначених символів. Арифметика препроцесора не має поняття адресації.

GCC на Mac визначає __LITTLE_ENDIAN__або__BIG_ENDIAN__

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

Потім ви можете додати більше умовних директив препроцесора на основі виявлення платформи, наприклад #ifdef _WIN32тощо.

Я вважаю, що саме про це просили. Я тестував це лише на маленькій ендіанській машині під msvc. Хтось просить підтвердити на великій ендіанській машині.

    #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

Як бічна примітка (конкретний для компілятора), за допомогою агресивного компілятора ви можете використовувати оптимізацію "усунення мертвого коду", щоб досягти такого ж ефекту, як час компіляції #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; // ?
    }

Вищезазначене спирається на те, що компілятор розпізнає постійні значення під час компіляції, повністю видаляє код всередині if (false) { ... }і замінює код, як if (true) { foo(); }на foo();Найгірший сценарій: компілятор не робить оптимізацію, ви все одно отримуєте правильний код, але трохи повільніше.

Якщо ви шукаєте тест часу компіляції та використовуєте gcc, ви можете зробити:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

Додаткову інформацію див. У документації gcc .

Фактично ви можете отримати доступ до пам'яті тимчасового об'єкта, використовуючи складений літерал (C99):

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

Який GCC оцінить під час компіляції.

"Мережева бібліотека С" пропонує функції для обробки витримки. А саме htons (), htonl (), ntohs () і ntohl () ... де n - "мережа" (тобто. Big-endian), а h - "господар" (тобто ендіантність машини, що працює на код).

Ці видимі "функції" (зазвичай) визначаються як макроси [див. <Netinet / in.h>], тому для їх використання немає накладних витрат на виконання.

Наступні макроси використовують ці "функції" для оцінки витримки.

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

В додаток:

Єдиний раз, коли мені потрібно дізнатися про ендіантність системи, це коли я виписую змінну [у файл / інше], яку може читати інша система невідомого ендіанства (для міжплатформової сумісності ) ... У таких випадках, ви можете скористатись функціями ендіана безпосередньо:

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

Використовуйте вбудовану функцію, а не макрос. Крім того, вам потрібно зберегти щось у пам'яті, що є не дуже приємним побічним ефектом макросу.

Ви можете перетворити його в короткий макрос, використовуючи статичну або глобальну змінну, наприклад:

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

Поки немає портативного #define або чогось, на що можна покластися, платформи надають стандартні функції для перетворення на ендіан вашого "хоста" та з нього.

Як правило, ви робите сховище - на диск або мережу - використовуючи "мережевий ендіан", який є BIG endian, і локальний обчислення, використовуючи хост ендіан (який на x86 - ЛІТТЕ ендіан). Ви використовуєте htons()та ntohs()та друзів для перетворення між ними.

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

Не забувайте, що цілеспрямованість - це не вся історія - розмір charможе бути не 8 біт (наприклад, DSP), заперечення доповнення двох не гарантується (наприклад, Cray), може знадобитися чітке вирівнювання (наприклад, SPARC, також ARM врізається в середину -endian, коли не узгоджено ) тощо, тощо

Можливо, буде кращою ідеєю націлити на певну архітектуру процесора .

Наприклад:

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

Зауважте, що це рішення також не є надто портативним, на жаль, оскільки воно залежить від конкретних визначень компілятора (стандарт не існує, але ось приємна збірка таких визначень).

Спробуйте це:

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

   TEST;
}

Зверніть увагу, що більшість відповідей тут не є портативними, оскільки сьогодні компілятори оцінять ці відповіді за час компіляції (залежить від оптимізації) та повернуть конкретне значення, виходячи з конкретної витримки, тоді як фактична машинна небезпека може відрізнятися. Значення, на які тестується ендіантність, ніколи не дотягнуться до системної пам’яті, таким чином реальний виконаний код поверне той же результат незалежно від фактичної витримки.

Для прикладу , в ARM Cortex-M3 впроваджена порядок байт буде відображати в бітовому статус AIRCR.ENDIANNESS і компілятор не може знати це значення під час компіляції.

Вибір компіляції для деяких відповідей, запропонованих тут:

https://godbolt.org/z/GJGNE2 для цієї відповіді,

https://godbolt.org/z/Yv-pyJ для цього відповіді тощо.

Для її вирішення вам потрібно буде використовувати volatileкласифікатор. Yogeesh H T«S відповідь ближче всього один для сьогоднішнього реального використання життя, але так як Christophпередбачає більш комплексне рішення, невелике виправлення до його відповіді буде зробити відповідь повним, просто додайте volatileдо оголошення союзу: static const volatile union.

Це гарантувало б збереження та читання з пам'яті, яке потрібно для визначення витривалості.

Якщо ви скидаєте препроцесор #defines

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

Зазвичай ви можете знайти речі, які допоможуть вам. З логікою часу компіляції.

#define __LITTLE_ENDIAN__ 1
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

Однак різні компілятори можуть мати різні визначення.

Мою відповідь не так, як запитували, але дійсно просто дізнатися, чи ваша система мало ендіака чи велика ендіанка?

Код:

#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 Код для перевірки, чи є система малоіндійською чи великоіндійською.

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

Макрос, щоб знайти ендіанні

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

або

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