##Consider exploiting the compiler
Consider exploiting the compiler
Your compiler already needs to know the endianness of the target system. There's a good chance that it exposes that information in a way you can access. gcc
for example defines macros, so you can do:
#if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__))
and have different code blocks as appropriate.
##Don't repeat yourself
Don't repeat yourself
Your current approach declares endian_test
as a local variable. Depending on how clever your compiler is, it may optimize some of the work out for you. However you should consider giving it hints by declaring the variable as a static
(you don't need a new instance for every call) const
(you don't need to modify it after its declaration).
##Consider exploiting the compiler
Your compiler already needs to know the endianness of the target system. There's a good chance that it exposes that information in a way you can access. gcc
for example defines macros, so you can do:
#if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__))
and have different code blocks as appropriate.
##Don't repeat yourself
Your current approach declares endian_test
as a local variable. Depending on how clever your compiler is, it may optimize some of the work out for you. However you should consider giving it hints by declaring the variable as a static
(you don't need a new instance for every call) const
(you don't need to modify it after its declaration).
Consider exploiting the compiler
Your compiler already needs to know the endianness of the target system. There's a good chance that it exposes that information in a way you can access. gcc
for example defines macros, so you can do:
#if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__))
and have different code blocks as appropriate.
Don't repeat yourself
Your current approach declares endian_test
as a local variable. Depending on how clever your compiler is, it may optimize some of the work out for you. However you should consider giving it hints by declaring the variable as a static
(you don't need a new instance for every call) const
(you don't need to modify it after its declaration).
- 87.3k
- 14
- 104
- 322
Consider exploiting the compiler ##Consider exploiting the compiler
Your compiler already needs to know the endianness of the target system. There's a good chance that it exposes that information in a way you can access. gcc
for example defines macros, so you can do:
#if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__))
and have different code blocks as appropriate.
Don't repeat yourself ##Don't repeat yourself
Your current approach declares endian_test
as a local variable. Depending on how clever your compiler is, it may optimize some of the work out for you. However you should consider giving it hints by declaring the variable as a static
(you don't need a new instance for every call) const
(you don't need to modify it after it'sits declaration).
Consider exploiting the compiler
Your compiler already needs to know the endianness of the target system. There's a good chance that it exposes that information in a way you can access. gcc
for example defines macros, so you can do:
#if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__))
and have different code blocks as appropriate.
Don't repeat yourself
Your current approach declares endian_test
as a local variable. Depending on how clever your compiler is, it may optimize some of the work out for you. However you should consider giving it hints by declaring the variable as a static
(you don't need a new instance for every call) const
(you don't need to modify it after it's declaration).
##Consider exploiting the compiler
Your compiler already needs to know the endianness of the target system. There's a good chance that it exposes that information in a way you can access. gcc
for example defines macros, so you can do:
#if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__))
and have different code blocks as appropriate.
##Don't repeat yourself
Your current approach declares endian_test
as a local variable. Depending on how clever your compiler is, it may optimize some of the work out for you. However you should consider giving it hints by declaring the variable as a static
(you don't need a new instance for every call) const
(you don't need to modify it after its declaration).
Consider exploiting the compiler
Your compiler already needs to know the endianness of the target system. There's a good chance that it exposes that information in a way you can access. gcc
for example defines macros, so you can do:
#if ((__BYTE_ORDER__) == (__ORDER_LITTLE_ENDIAN__))
and have different code blocks as appropriate.
Don't repeat yourself
Your current approach declares endian_test
as a local variable. Depending on how clever your compiler is, it may optimize some of the work out for you. However you should consider giving it hints by declaring the variable as a static
(you don't need a new instance for every call) const
(you don't need to modify it after it's declaration).