Cómo el C++0x estándar define Auto de C++ múltiples declaraciones?

Question

mmm, yo tengo un poco de confusión acerca de varios auto declaraciones en las próximas C++0x estándar.

auto a = 10, b = 3.f , * c = new Class();

en algún lugar he leído que no está permitido.La razón era(?) debido a que no estaba claro si las sucesivas declaraciones deben tener el mismo tipo de la primera , (int en el ejemplo) , o no.

Una posible traducción 1:

int a = 10; 
int b = 3.f; 
int * c = new Class ();

causando un error

Una posible traducción 2:

int a = 10;
float b = 3.f;
Class * c = new Class (); 

cómo se dio lugar en el estándar?

Si puedo decir que mi punto de VISTA, la traducción #2 fue el más obiouvs, al menos para mí que soy un regular C++ usuario .Quiero decir, para mí "toda variable declarada es del mismo tipo declarado", la bruja es automático.Traducción #1 sería realmente onu-intuitivo para mí.

Adiós QbProg

Answer 1

Probablemente no sea la última, pero mi C++0x proyecto de norma de junio de 2008, dice que puede hacer lo siguiente:

auto x = 5; // OK: x has type int
const auto *v = &x, u = 6; // OK: v has type const int*, u has type const int

Así que a menos que algo ha cambiado desde junio de este es (o será) permite una forma limitada con un muy intuitiva interpretación.

La limitación es que si usted no quiere a la cadena múltiple auto declaraciones como esta (usando el ejemplo de arriba), funciona porque el tipo inferido de v y u tendrá el mismo "tipo de base' (int en este caso) para utilizar un término inexacto.

Si desea que la regla precisa, El proyecto de norma dice esto:

Si la lista de declarators contiene más de una sentencia declarativa, el tipo de cada variable declarada se determina como se describe por encima de.Si el tipo de deducir para el parámetro de plantilla U no es el mismo en cada deducción, el programa está mal formado.

donde el "deducir los parámetros de una plantilla U" está determinado por:

el deducirse tipo del parámetro u en la llamada f(expr) de la siguiente inventado plantilla de función:

 `template <class U> void f(const U& u);`

Por qué hemos llegado con esta regla en lugar de decir algo como:

auto a = 10, b = 3.f , * c = new Class();

es equivalente a:

auto a = 10;
auto b = 3.f;
auto * c = new Class();

No sé.Pero no escribo compiladores.Probablemente algo que ver con una vez que hayas descubierto el auto palabras clave reemplaza, no se puede cambiar en la misma instrucción.

Tomemos, por ejemplo:

int x = 5;
CFoo * c = new CFoo();

auto  a1 = x,       b1 = c; // why should this be permitted if
int   a2 = x, CFoo* b2 = c; // this is not?

En cualquier caso, yo no soy un fan de poner a varias declaraciones en la misma declaración de todos modos.

Answer 2

El borrador del estándar la sección 7.1.6.4 implica que no se pueden mezclar tipos como en una posible traducción 2. Por lo tanto, ninguna de las posibles traducciones es válida.

Answer 3

Hay algunos puntos que creo que contribuyen a la redacción actual. El primero es la consistencia. Si escribe una declaración como:

int j;
int i = 0, *k = &j;

Luego, los dos tipos usan int en algún lugar de su tipo. Es un error, por ejemplo, si 'j' era un 'const int'. Hacer que auto funcione igual es & Quot; consistente & Quot; con el modelo actual para tales declaraciones.

Existe una ventaja práctica desde la perspectiva de un escritor compilador. Ya existe la maquinaria en los compiladores para realizar una deducción de tipo para una llamada de función (que es como auto se describe como operativo). La regla anterior es coherente con la regla de que la deducción para un parámetro de plantilla debe dar como resultado el mismo tipo:

template <typename T> void foo (T, T*);

void bar ()
{
  int i;
  const int j = 0;

  foo (i, &i);  // OK deduction succeeds T == int
  foo (i, &j);  // ERROR deduction fails T == int or const int.
}

Una implementación fácil para auto es reutilizar la mecánica existente para deducir el tipo de auto , y debido a la consistencia con los comportamientos actuales, el resultado no será demasiado sorprendente a las personas.

Finalmente, y este es probablemente el punto más importante en mi opinión. El modelo actual es conservador y funciona de manera muy similar a las construcciones de lenguaje existentes en C ++. Por lo tanto, las posibilidades de que resulte en un error de idioma de detención del espectáculo son muy escasas. Sin embargo, el modelo actual puede ampliarse fácilmente en el futuro para contener los otros ejemplos que enumere en su pregunta.

Además, esa expansión no romperá el código que usa la redacción actual de auto . Considere si hicieron esto al revés. Si la versión expandida de auto fuera la primera versión, y esto resultara en un defecto extraño y fatal con la palabra clave, entonces requeriría la eliminación de una característica del lenguaje del estándar, algo que casi nunca sucede como lo más probable es que rompa el código.

Answer 4

El primero se alinearía con el funcionamiento de la inferencia de tipos en el tipo de retorno del operador?: