¿Cómo escribo un literal corto en C ++?

Question

Pregunta muy básica: ¿cómo escribo un short literal en C ++?

Sé lo siguiente:

• 2 es un int
• 2U es un unsigned int
• 2L es un long
• 2LL es un long long
• 2.0f es un float
• 2.0 es un double
• '\ 2' es un char .

¿Pero cómo escribiría un literal short ? Intenté 2S pero eso da una advertencia del compilador.

Answer 1

((short)2)

Sí, no es estrictamente un literal corto, sino más bien un int-cast, pero el comportamiento es el mismo y creo que no hay una forma directa de hacerlo.

  

Eso es lo que he estado haciendo porque no pude encontrar nada al respecto. Supongo que el compilador sería lo suficientemente inteligente como para compilar esto como si fuera un literal corto (es decir, en realidad no asignaría un int y luego lo lanzaría cada vez).

Lo siguiente ilustra cuánto debes preocuparte por esto:

a = 2L;
b = 2.0;
c = (short)2;
d = '\2';

Compilar - > desmontar - >

movl    $2, _a
movl    $2, _b
movl    $2, _c
movl    $2, _d

Answer 2

C ++ 11 te da bastante cerca de lo que quieres. (Busque " literales definidos por el usuario " para obtener más información.)

#include <cstdint>

inline std::uint16_t operator "" _u(unsigned long long value)
{
    return static_cast<std::uint16_t>(value);
}

void func(std::uint32_t value); // 1
void func(std::uint16_t value); // 2

func(0x1234U); // calls 1
func(0x1234_u); // calls 2

// also
inline std::int16_t operator "" _s(unsigned long long value)
{
    return static_cast<std::int16_t>(value);
}

Answer 3

Incluso los escritores del estándar C99 se vieron atrapados por esto. Este es un fragmento de la implementación del dominio público stdint.h de Danny Smith:

/* 7.18.4.1  Macros for minimum-width integer constants

    Accoding to Douglas Gwyn <gwyn@arl.mil>:
    "This spec was changed in ISO/IEC 9899:1999 TC1; in ISO/IEC
    9899:1999 as initially published, the expansion was required
    to be an integer constant of precisely matching type, which
    is impossible to accomplish for the shorter types on most
    platforms, because C99 provides no standard way to designate
    an integer constant with width less than that of type int.
    TC1 changed this to require just an integer constant
    *expression* with *promoted* type."
*/

Answer 4

Si usa Microsoft Visual C ++, hay sufijos literales disponibles para cada tipo de entero:

auto var1 = 10i8;  // char
auto var2 = 10ui8; // unsigned char

auto var3 = 10i16;  // short
auto var4 = 10ui16; // unsigned short

auto var5 = 10i32;  // int
auto var6 = 10ui32; // unsigned int

auto var7 = 10i64;  // long long
auto var8 = 10ui64; // unsigned long long

Tenga en cuenta que estas son extensiones no estándar y no son portátiles . De hecho, ni siquiera pude encontrar información sobre estos sufijos en MSDN.

Answer 5

También puede utilizar la sintaxis de pseudo constructor.

short(2)

Lo encuentro más legible que el casting.

Answer 6

Por lo que sé, no lo hace, no hay tal sufijo. Sin embargo, la mayoría de los compiladores avisarán si un literal entero es demasiado grande para que quepa en cualquier variable en la que estés intentando almacenarlo.