¿Hay alguna función htonl "estándar" para enteros de 64 bits en C++?

Question

Estoy trabajando en una implementación del protocolo Memcache que, en algunos puntos, usa valores enteros de 64 bits. Estos valores deben almacenarse en "orden de bytes de red".

Ojalá hubiera alguna función de uint64_t htonll(uint64_t value) para hacer el cambio, pero desafortunadamente, si existe, no pude encontrarlo.

Así que tengo 1 o 2 preguntas:

• ¿Hay alguna portátil (Windows, Linux, AIX) función estándar de hacer esto?
• Si no existe tal función, ¿cómo la implementaría?

Tengo en mente una implementación básica, pero no sé cómo comprobar el endianness en tiempo de compilación para hacer que el código sea portátil. Entonces su ayuda es más que bienvenida aquí;)

Gracias.

---

Aquí está la solución final que escribí, gracias a la solución de Brian.

uint64_t htonll(uint64_t value) 
{ 
    // The answer is 42 
    static const int num = 42; 

    // Check the endianness 
    if (*reinterpret_cast<const char*>(&num) == num) 
    { 
     const uint32_t high_part = htonl(static_cast<uint32_t>(value >> 32)); 
     const uint32_t low_part = htonl(static_cast<uint32_t>(value & 0xFFFFFFFFLL)); 

     return (static_cast<uint64_t>(low_part) << 32) | high_part; 
    } else 
    { 
     return value; 
    } 
} 

Answer 1

Usted probablemente está buscando bswap_64 creo que es compatible prácticamente en todas partes, pero yo no diría que es estándar.

Puede verificar fácilmente la endianidad creando un int con un valor de 1, convirtiendo la dirección de su int como char* y verificando el valor del primer byte.

Por ejemplo:

int num = 42; 
if(*(char *)&num == 42) 
{ 
    //Little Endian 
} 
else 
{ 
    //Big Endian 
} 

Sabiendo esto también se puede hacer una función simple que hace el intercambio.

---

También es posible usar siempre impulso que contiene macros endian que son multiplataforma portátil.

Answer 2

EDIT: la combinación de los dos (código de Brian utilizado):

uint64_t htonll(uint64_t value) 
{ 
    int num = 42; 
    if(*(char *)&num == 42) 
      return (htonl(value & 0xFFFFFFFF) << 32LL) | htonl(value >> 32); 
    else 
      return value; 
} 

Advertencia: código no probado! Por favor prueba antes de usar.

Answer 3

Esto parece funcionar en C; ¿Hice algo mal?

uint64_t htonll(uint64_t value) { 
    int num = 42; 
    if (*(char *)&num == 42) { 
     uint32_t high_part = htonl((uint32_t)(value >> 32)); 
     uint32_t low_part = htonl((uint32_t)(value & 0xFFFFFFFFLL)); 
     return (((uint64_t)low_part) << 32) | high_part; 
    } else { 
     return value; 
    } 
} 

Answer 4

Para reducir la sobrecarga de la "si num == ..." Usa el pre-procesador define:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 
#else 
#endif 

Answer 5

#define htonll(x) ((1==htonl(1)) ? (x) : ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32)) 
#define ntohll(x) ((1==ntohl(1)) ? (x) : ((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32)) 

La prueba (1 htonl == (1)) simplemente determina (en tiempo de ejecución tristemente) si la arquitectura de hardware requiere el intercambio de bytes. No hay formas portátiles de determinar en tiempo de compilación qué es la arquitectura, por lo que recurrimos al uso de "htonl", que es lo más portátil posible en esta situación. Si se requiere el intercambio de bytes, intercambiamos 32 bits a la vez usando htonl (recordando intercambiar también las dos palabras de 32 bits).

Answer 6

Usted puede tratar con uint64_t htobe64(uint64_t host_64bits) & uint64_t be64toh(uint64_t big_endian_64bits) para viceversa.