Detecting Endianness Programmatically in a C++ Program

Determining endianness at compile time [duplicate]

This is for compile time checking

You could use information from the boost header file endian.hpp, which covers many platforms.

edit for runtime checking

bool isLittleEndian()
{
    short int number = 0x1;
    char *numPtr = (char*)&number;
    return (numPtr[0] == 1);
}

Create an integer, and read its first byte (least significant byte). If that byte is 1, then the system is little endian, otherwise it's big endian.

edit Thinking about it

Yes you could run into a potential issue in some platforms (can't think of any) where sizeof(char) == sizeof(short int). You could use fixed width multi-byte integral types available in <stdint.h>, or if your platform doesn't have it, again you could adapt a boost header for your use: stdint.hpp

Detecting Endianness

At compile time in C you can't do much more than trusting preprocessor #defines, and there are no standard solutions because the C standard isn't concerned with endianness.

Still, you could add an assertion that is done at runtime at the start of the program to make sure that the assumption done when compiling was true:

inline int IsBigEndian()
{
    int i=1;
    return ! *((char *)&i);
}

/* ... */

#ifdef COMPILED_FOR_BIG_ENDIAN
assert(IsBigEndian());
#elif COMPILED_FOR_LITTLE_ENDIAN
assert(!IsBigEndian());
#else
#error "No endianness macro defined"
#endif

(where COMPILED_FOR_BIG_ENDIAN and COMPILED_FOR_LITTLE_ENDIAN are macros #defined previously according to your preprocessor endianness checks)

C program to check little vs. big endian [duplicate]

In short, yes.

Suppose we are on a 32-bit machine.

If it is little endian, the x in the memory will be something like:

       higher memory
          ----->
    +----+----+----+----+
    |0x01|0x00|0x00|0x00|
    +----+----+----+----+
    A
    |
   &x

so (char*)(&x) == 1, and *y+48 == '1'. (48 is the ascii code of '0')

If it is big endian, it will be:

    +----+----+----+----+
    |0x00|0x00|0x00|0x01|
    +----+----+----+----+
    A
    |
   &x

so this one will be '0'.

How to determine endianness at compile-time?

C++20 added std::endian to <bit>* which can be used in a constexpr context.

Live example of below code:

if constexpr (std::endian::native == std::endian::little) {
    std::cout << "litle endian\n";
} else if constexpr(std::endian::native == std::endian::big) {
    std::cout << "big endian\n";
} else {
    std::cout << "something silly\n";
}

* It was originally <type_traits> and will be there in older implementations.

How can I find Endian-ness of my PC programmatically using C? [duplicate]

Why you need a library if you can find it like this? :)

int num = 1;

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

Detect system endianness in one line? [duplicate]

2 ways

1) Have a preprocessor you define for various platforms so you can act on various endianness at compile time instead of runtime (significantly faster but harder to implement without knowing all platforms

2) similar to your function:

inline bool isLittleEndian()
{
    static const int i = 1;
    static const char* const c = reinterpret_cast<const char* const>(&i);
    return (*c == 1);
}
...
static const bool _systemEndianness = isLittleEndian ();

Finding Endianness in C without implicit/explicit casting

There's no such thing as "implicit casting" - a cast is an explicit operator. If what you're looking for is a way to observe endianness without examining the representation of an object, however, there is no way. Endianness is purely a property of representation, not of values, so if you restrict yourself from accessing representations, it doesn't exist. This is why most good code should not care about endianness.

If you do want to cheat and access representations, but without it looking like a cast, here are some ideas:

int i = 1;
char c;
memcpy(&c, &i, 1);
c;

or:

union { int i; char c; } x = { 1 };
x.c;

or:

int i = 1;
FILE *f = tmpfile();
fwrite(&i, sizeof i, 1, f);
rewind(f);
getc(f);

or using any library function that might do stuff like this for you under the hood. You could also, if you're on a POSIX system or any other system with socket operations, do:

htonl(1) != 1;

But all of these rely either on inspecting representations, or hard-coded assumptions in the implementation about what the target endianness is.

---

Related Topics