Warum erlaubt uns C++, den Variablennamen bei der Deklaration einer Variablen in Klammern zu setzen?

Question

Zum Beispiel einer Erklärung, wie das:

int (x) = 0; 

Oder auch, dass:

int (((x))) = 0; 

ich auf das, weil in meinem Code stolperte ich ein Fragment ähnlich den folgenden, einen haben passiert:

struct B 
{ 
}; 

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

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

Offensichtlich wollte ich Objekt C konstruieren, die dann etwas nützliches in seinem Destruktor tun würde. Wie dem auch sei, der Compiler behandelt C (y); als eine Deklaration der Variablen y mit dem Typ C und gibt daher einen Fehler über y Neudefinition aus. Interessante Sache ist, dass, wenn ich es als C (y).f() oder als etwas wie C (static_cast<B*> (y)) schreibe, es wie beabsichtigt kompilieren wird. Die beste moderne Problemumgehung ist die Verwendung von {} im Konstruktoraufruf natürlich.

So wie ich später herausgefunden, ist es möglich, Variablen wie int (x) = 0; oder sogar int (((x))) = 0; zu deklarieren, aber ich habe noch nie jemanden gesehen, der solche Deklarationen tatsächlich verwendet. Ich bin also interessiert - was ist der Zweck einer solchen Möglichkeit, weil ich jetzt sehe, dass es nur den Fall ähnlich dem berüchtigten "ärgerlichsten Parse" schafft und nichts nützliches hinzufügt?

Answer 1

Gruppierung.

Als besonderes Beispiel dazu, dass Sie eine Variable vom Typ Funktion wie

int f(int); 

Jetzt erklären können, wie würden Sie einen Zeiger auf so etwas erklären?

int *f(int); 

Nein, funktioniert nicht! Dies wird als eine Funktion interpretiert, die int* zurückgibt. Sie müssen in den Klammern hinzuzufügen, um es richtig zu machen analysiert:

int (*f)(int); 

Das gleiche Geschäft mit Arrays:

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

Answer 2

Es ist in der Regel Klammern in solchen Erklärungen verwenden darf, weil die Erklärung, aus dem syntaktische Sicht sieht immer wie folgt aus:

<front type> <specification>; 

Zum Beispiel in der folgenden Erklärung:

int* p[2]; 

Der "Fronttyp" ist int (nicht int*) und die "Spezifikation" ist * p[2].

Die Regel besteht darin, dass Sie im Abschnitt "Spezifikation" beliebig viele Klammern verwenden können, da sie manchmal nicht eindeutig voneinander zu trennen sind.Zum Beispiel:

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

Der Zeiger auf ein Array ist ein seltener Fall, aber die gleiche Situation, die Sie mit einem Zeiger auf Funktion haben:

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

Dies ist die direkte Antwort auf Ihre Frage. Wenn Ihre Frage bezieht sich auf die Aussage wie C(y), dann:

• Put Klammern um den gesamten Ausdruck - (C(y)) und Sie bekommen, was Sie
• wollte ein temporäres Objekt Diese Aussage tut nichts, aber sie schaffen, die nicht mehr zu Leben nach dieser Anweisung endet (ich hoffe, das ist, was Sie vorhatten).