c++ - error - Declarar una variable con dos tipos: "int char"

c error conflicting types for function

Question

Soy un principiante de C ++, y estoy leyendo Programación de Bjarne Stroustrup: Principios y práctica utilizando C ++ .

En la sección 3.9.2 conversiones inseguras , el autor mencionó

Cuando el inicializador es un literal entero, el compilador puede verificar el valor real y aceptar valores que no impliquen un estrechamiento:

int char b1 {1000};     // error: narrowing (assuming 8-bit chars)

Estoy sorprendido por esta declaración. Utiliza dos tipos ( int y char ). Nunca antes había visto tal declaración en Java y Swift (los dos lenguajes con los que estoy relativamente familiarizado). ¿Es este un error tipográfico o una sintaxis de C ++ válida?

Answer 1

El libro esta equivocado

La secuencia token int char b1{1000}; No es semánticamente válido C ++.

Está intentando declarar b1 con más de un tipo, lo que no tiene sentido.

Answer 2

Es un error en el libro. Esa no es una declaración de C ++ válida, incluso sin la supuesta conversión de reducción.

Sin embargo, no se menciona en ninguna de las erratas en la página de Bjarne Stroustrup (cuarta impresión y anteriores), lo cual es extraño. Es un error suficientemente claro. Me imagino que, como se ha comentado con //error pocas personas notan el error en la declaración.

Answer 3

Está mal. En C / C ++, las declaraciones de varios tipos se pueden lograr mediante el uso de uniones. P.ej:

union {
    int i;
    char c;
} var;

var.i = 42;
/* OR */
var.c = ‘c’;

El almacenamiento es el mismo, por lo que .cy .i son solo manejadores por tipo para el mismo valor.

Answer 4

Esto es incorrecto en la sintaxis de C / C ++. Además de la union s (vea la respuesta de @Alex), hay una forma en C ++ de almacenar solo uno de los tipos disponibles llamado std::variant (unión de tipo seguro):

#include <variant>
#include <string>

int main()
{
    std::variant<int, float> v, w;
    v = 12; // v contains int
    int i = std::get<int>(v);
    w = std::get<int>(v);
    w = std::get<0>(v); // same effect as the previous line
    w = v; // same effect as the previous line

//  std::get<double>(v); // error: no double in [int, float]
//  std::get<3>(v);      // error: valid index values are 0 and 1

    try {
      std::get<float>(w); // w contains int, not float: will throw
    }
    catch (std::bad_variant_access&) {}

    std::variant<std::string> v("abc"); // converting constructors work when unambiguous
    v = "def"; // converting assignment also works when unambiguous
}