válido variable valor una siguientes siguiente separadores que programacion nombre literales literal lenguaje las enteros cuál cadenas c++ literals

variable - ¿Cómo escribo un breve literal en C++?



¿cuál de las siguientes cadenas es un nombre de variable válido ? (6)

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

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 short literal? Intenté 2S pero eso da una advertencia del compilador.


Hasta donde yo sé, no, no hay tal sufijo. La mayoría de los compiladores advertirán si un literal entero es demasiado grande para caber en cualquier variable en la que intente almacenarlo.


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

/* 7.18.4.1 Macros for minimum-width integer constants Accoding to Douglas Gwyn <[email protected]>: "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." */


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 extensiones no son estándar y no son portátiles . De hecho, ni siquiera pude encontrar información sobre estos sufijos en MSDN.


También puede usar la sintaxis de pseudoconstructor.

short(2)

Lo encuentro más legible que el casting.


((short)2)

Sí, no es estrictamente un breve literal, más de un casted-int, 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 breve literal (es decir, no asignaría realmente un int y luego lo lanzaría cada vez).

Lo siguiente ilustra cuánto debe preocuparse 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