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


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 un 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 variable y con tipo C y así 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)) 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?


76
2018-04-16 13:05


origen


Respuestas:


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 regresa 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

76
2018-04-16 13:11



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 tu pregunta es sobre la declaración como C(y), entonces:

  • Ponga paréntesis alrededor de toda la expresión - (C(y)) y obtendrás lo que querías
  • 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).

17
2018-04-16 13:14