2011-01-18 7 views
7

Hace poco encontré este constructo: int (m); que parece ser equivalente a: int m;sintaxis de desclasificación variable de C++

Curiosamente, nunca antes había visto este idioma en particular. ¿Puede alguien indicarme una referencia en la que pueda leer las especificaciones al respecto, o simplemente explicar directamente? ¿Esto también funciona en C recta?

Gracias, ConfusedDeveloper

+3

Si bien esta es la sintaxis perfectamente legal para declarar un entero, por el bien de sus compañeros desarrolladores, cámbielo a 'int m;'. –

Respuesta

11

No es un "idioma". Es solo un par de paréntesis redundantes. Gramaticalmente, pueden estar allí, pero no sirven para nada.

veces similares paréntesis, aparentemente superfluos pueden ser utilizados para resolver la ambigüedad en las declaraciones de C++, como

int a(int()); 

que declara una función se puede convertir en

int a((int())); 

que es equivalente a

int a = int(); 

y define una variable. Pero esto no es exactamente lo que tienes en tu caso.

+2

Minit nitpick: no siempre es redundante. Por ejemplo, puede escribir 'cout << int (n)', pero no 'cout << int n'. – suszterpatt

+0

Gracias, eso es útil. Por cierto, definición de modismo: una expresión sancionada por el uso que es peculiar de un idioma. Parece una descripción apropiada. – ConfusedDeveloper

+7

@suszterpatt: La pregunta fue específicamente sobre declaraciones. Su ejemplo no implica ninguna declaración en absoluto. Su ejemplo es sobre '()' en expresiones, que es una historia completamente diferente. – AnT

1

También se usa para lanzar. Al igual que,

double m= 10.0; 
int n= int(m); 
+0

La pregunta es sobre declaraciones, y esto no es una declaración en absoluto, solo algo que se ve similar. – aschepler

+2

@aschepler: Sí. Dado que se ve similar, es por eso que lo publico. Solo quería decirle que así es también como se usa. :-) – Nawaz

1

Además de otras respuestas, a veces declarador tiene que estar entre paréntesis.
Por ejemplo:

struct A {}; 

struct B { A a; }; 

namespace N { 
    struct B { int a; }; 

    void f() 
    { 
    A (::B::*p) = &::B::a; // this() cannot be omitted 
    } 
} 

Si () se omite en el código anterior, el compilador reconoce una consecutivo anidada nombre especificador A::B en lugar de A y ::B, y emitirá un error.
Este paréntesis es necesario, pero a veces conduce a una situación engañosa.

struct A { 
    int m; 
    A() {} 
    A(int) {} // this isn't called 
}; 

int i; 

int main() 
{ 
    A(i); // this is a declaration 
    i.m = 1; // ok 
} 

En el código anterior, A(i) es una declaración (y también una definición en este caso) de un objeto i, en lugar de una expresión llamada al constructor con un argumento inti.

Espero que esto ayude.