Perché il C ++ ci consente di racchiudere il nome della variabile tra parentesi quando si dichiara una variabile?

Ad esempio una dichiarazione come quella:

int (x) = 0;

O anche quello:

int (((x))) = 0;

Mi sono imbattuto in questo perché nel mio codice mi è capitato di avere un frammento simile al seguente:

struct B
{
};

struct C
{
  C (B *) {}
  void f () {};
};

int main()
{
  B *y;
  C (y);
}

Ovviamente volevo costruire un oggetto Cche poi avrebbe fatto qualcosa di utile nel suo distruttore. Tuttavia, come accade il compilatore tratta C (y);come una dichiarazione di variabile ycon tipo Ce quindi stampa un errore sulla yridefinizione. La cosa interessante è che se lo scrivo come C (y).f ()o come qualcosa di simile C (static_cast<B*> (y))verrà compilato come previsto. La migliore soluzione alternativa moderna è quella di utilizzare {}nella chiamata al costruttore, ovviamente.

Quindi, come ho capito dopo, è possibile dichiarare variabili come int (x) = 0;o anche int (((x))) = 0;ma non ho mai visto nessuno usare effettivamente dichiarazioni come questa. Quindi mi interessa: qual è lo scopo di tale possibilità perché per ora vedo che crea solo il caso simile al famigerato "analisi più irritante" e non aggiunge nulla di utile?

Raggruppamento.

Come esempio particolare, considera che puoi dichiarare una variabile di tipo funzione come

int f(int);

Ora, come dichiareresti un puntatore a una cosa del genere?

int *f(int);

No, non funziona! Questo viene interpretato come una funzione di ritorno int*. È necessario aggiungere le parentesi per farlo analizzare nel modo giusto:

int (*f)(int);

La stessa cosa con gli array:

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

In genere è consentito usare le parentesi in tali dichiarazioni perché la dichiarazione, dal punto di vista sintattico, è sempre così:

<front type> <specification>;

Ad esempio, nella seguente dichiarazione:

int* p[2];

Il "tipo di fronte" è int(non int*) e la "specifica" è * p[2].

La regola è che puoi usare qualsiasi numero di parentesi secondo necessità nella parte "specifica" perché a volte è inevitabile disambiguare. Per esempio:

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

Il puntatore a un array è un caso raro, tuttavia la stessa situazione che hai con un puntatore a funzione:

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

Questa è la risposta diretta alla tua domanda. Se la tua domanda riguarda l'affermazione del tipo C(y), allora:

• Metti le parentesi attorno all'intera espressione (C(y))e otterrai ciò che desideri
• Questa dichiarazione non fa altro che creare un oggetto temporaneo, che cessa di vivere al termine di questa istruzione (spero che questo sia ciò che intendevi fare).