tipos - ¿Por qué C++ nos permite rodear el nombre de la variable entre paréntesis cuando se declara una variable?

que es int en c++

Question

Por ejemplo, una declaración como esa:

int (x) = 0;

O incluso eso:

int (((x))) = 0;

Me encontré con esto porque en mi código tenía un fragmento similar al siguiente:

struct B
{
};
struct C
{
C (B *) {}
void f () {};
};
int main()
{
B *y;
C (y);
}

Obviamente, quería construir el objeto C que luego haría algo útil en su destructor. Sin embargo, como sucede, el compilador trata C (y); como una declaración de la variable y con el tipo C y, por lo tanto, se imprime un error sobre y redefinición. Lo interesante es que si lo escribo como C (y).f () o algo así como C (static_cast<B*> (y)) se compilará según lo previsto. La mejor solución moderna es usar {} en llamada de constructor, por supuesto.

Entonces, como descubrí después de eso, es posible declarar variables como int (x) = 0; o incluso int (((x))) = 0; pero nunca he visto a nadie usando declaraciones como esta. Entonces, estoy interesado. ¿Cuál es el propósito de tal posibilidad porque, por ahora, veo que solo crea el caso similar al notorio "análisis más irritante" y no agrega nada útil?

Answer 1

Agrupamiento.

Como ejemplo particular, considere que puede declarar una variable de tipo de función, como

int f(int);

Ahora, ¿cómo declararías un puntero a tal cosa?

int *f(int);

¡No, no funciona! Esto se interpreta como una función que devuelve int* . Debe agregar el paréntesis para que se pueda analizar de la manera correcta:

int (*f)(int);

El mismo trato con las matrices:

int *x[5]; // array of five int*
int (*x)[5]; // pointer to array of five int

Answer 2

En general, se permite el uso de paréntesis en tales declaraciones porque la declaración, desde el punto de vista sintáctico siempre se ve así:

<front type> <specification>;

Por ejemplo, en la siguiente declaración:

int* p[2];

El "tipo de frente" es int (no int* ) y la "especificación" es * p[2] .

La regla es que puede usar cualquier número de paréntesis según sea necesario en la parte de "especificación" porque a veces son inevitables para desambiguar. Por ejemplo:

int* p[2]; // array of 2 pointers to int; same as int (*p[2]);
int (*p)[2]; // pointer to an array of 2 ints

El puntero a una matriz es un caso raro, sin embargo, la misma situación que tiene con un puntero a la función:

int (*func(int)); // declares a function returning int*
int (*func)(int); // declares a pointer to function returning int

Esta es la respuesta directa a tu pregunta. Si su pregunta es sobre la afirmación como C(y) , entonces:

• Ponga paréntesis alrededor de toda la expresión - (C(y)) y obtendrá lo que quería
• Esta afirmación no hace más que crear un objeto temporal, que deja de vivir después de que finaliza esta instrucción (espero que esto sea lo que pretendía hacer).