c++ - Comportamiento estándar para la inicialización directa de cortos sin firmar.

syntax casting

Question

Noté hoy que en el código de ejemplo:

void print(unsigned short a) {
std::cout << a << std::endl;
}

Inicialización y uso de trabajos como este:

print(short (5));

Pero no así:

print(unsigned short(6));

main.cpp: 16: 8: error: expresión primaria esperada antes de la impresión "sin firmar" (sin signo corto (6));

Y no tiene que ver con el tipo ya que esto también funciona:

typedef unsigned short ushort;
print(ushort (6));

Ejemplo vivo.

Así que fui a buscar lo que dice el estándar sobre la inicialización de valores. Resulta nada:

Los efectos de la inicialización de valores son:

1) Si T es un tipo de clase ...

2) si T es un tipo de clase no sindical ...

2) Si T es un tipo de clase ...

3) si T es un tipo de matriz, ..

4) de lo contrario , el objeto es cero inicializado.

Modificaciones realizadas por legibilidad. Fuente original .

¿Cuáles son las reglas sobre la inicialización de valores de los tipos de POD ? ¿Cuál es la razón por la que los tipos calificados unsigned no se pueden inicializar por valor? ¿Esto tiene más que ver con el hecho de que son rvalues ?

Answer 1

¿Cuál es la razón por la que los tipos calificados unsigned no se pueden inicializar por valor?

Es solo porque solo se puede usar el nombre de tipo de una sola palabra en la expresión de conversión funcional , mientras que el unsigned short no es un nombre de tipo de una sola palabra; short es

La expresión de conversión funcional consiste en un especificador de tipo simple o un especificador de typedef (en otras palabras, un nombre de tipo de una sola palabra: unsigned int(expression) o int*(expression) no son válidos), seguido de una sola expresión entre paréntesis.

Como demostró, puede usar typedef como solución alternativa, o agregar paréntesis para cambiarlo a expresión de estilo C, por ejemplo (unsigned short)(6) o (unsigned short)6 .

De la norma, §7.6.1.3 / 1 Conversión explícita de tipo (notación funcional) [expr.type.conv] :

Un simple-type-specifier o typename-specifier seguido de una lista de expresiones opcionales entre paréntesis o de una lista de iniciados (el inicializador) construye un valor del tipo especificado dado el inicializador.

Y simple-type-specifier :

simple-type-specifier:
nested-name-specifier opt
type-name
nested-name-specifier template simple-template-id
nested-name-specifier opt
template-name
char
char16_t
char32_t
wchar_t
bool
short
int
long
signed
unsigned
float
double
void
auto
decltype-specifier
type-name:
class-name
enum-name
typedef-name
simple-template-id
decltype-specifier:
decltype ( expression )
decltype ( auto )

typename-specifier :

typename-specifier:
typename nested-name-specifier identifier
typename nested-name-specifier template opt
simple-template-id

Answer 2

Eso es solo una falla en la gramática: los dos nombres de tipo de palabra no funcionan cuando se crean objetos temporales. Es decir, ninguno de estos trabajos.

template <typename T> void use(T);
int main() {
use(unsigned int());
use(const int());
use(long long());
}

La solución es utilizar un alias para el tipo respectivo, es decir, todos estos funcionan:

template <typename T> void use(T);
int main() {
{ using type = unsigned int; use(type()); }
{ using type = const int; use(type()); }
{ using type = long long; use(type()); }
}

Los paréntesis también pueden usarse para la inicialización de valores, aunque requieren el uso de curlies:

template <typename T> void use(T);
int main() {
use((unsigned int){});
use((const int){});
use((long long){});
}