Como C ++ 0x padrão define múltiplas declarações C ++ Auto?

Question

mmm, tenho apenas um pouco de confusão sobre várias declarações de automóveis no próximo C ++ 0x padrão.

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

em algum lugar eu li isso não é permitido. A razão era (?) Porque não era claro se as declarações consecutivos devem ter o mesmo tipo de primeira, (int no exemplo), ou não.

Possível tradução 1:

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

causando um erro

Possível tradução 2:

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

como ele é resultou no padrão?

Se eu posso dizer que o meu POV, tradução # 2 foi o maior obiouvs, pelo menos para mim que eu sou um regulares C ++ usuário. Quero dizer, para mim "cada variável declarada é do mesmo tipo declarado", bruxa é auto. Tradução # 1 seria muito un-intuitivo para mim.

Good Bye QbProg

Answer 1

Provavelmente não é o mais recente, mas meu C ++ 0x projecto de norma de junho de 2008 diz que você pode fazer o seguinte:

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

Assim, a menos que algo mudou desde junho deste é (ou será) permitido em uma forma limitada com uma interpretação bastante intuitivo.

A limitação é que, se você quer corda múltiplas declarações de automóveis como este (usando o exemplo acima), ele funciona porque o tipo inferido de v e u têm o mesmo 'tipo base' (int neste caso) para uso um termo impreciso.

Se você quiser que a regra precisa, o projecto de norma diz o seguinte:

Se a lista de declarators contém mais de um declarator, o tipo de cada variável declarada é determinado conforme descrito acima. Se o tipo de deduzida para o modelo parâmetro U não é o mesmo em cada dedução, o programa está mal-formado.

onde o "modelo deduzida parâmetro U" é determinada por:

o tipo deduzida do parâmetro u na chamada f (expr) do seguinte modelo de função inventada:

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

Por que eles vêm para cima com esta regra em vez de dizer algo como:

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

é equivalente a:

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

Eu não sei. Mas eu não escrever compiladores. Provavelmente algo a ver com uma vez que você já descobriu os os auto palavra-chave substitui, você não pode mudá-lo na mesma declaração.

Tome por exemplo:

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?

Em qualquer caso, eu não sou um fã de colocar múltiplas declarações na mesma declaração de qualquer maneira.

Answer 2

O projecto padrão secção 7.1.6.4 implica que você não pode misturar tipos como na tradução possível 2. tradução Então nem possível é válido.

Answer 3

Existem alguns pontos que eu acho que ajuda contribuir para a formulação actual. O primeiro é a consistência. Se você escrever uma declaração como:

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

Em seguida, os dois tipos tanto para uso int em algum lugar no seu tipo. É um erro, por exemplo, se o 'j' era um 'const int'. Tendo auto funcionam da mesma é "consistente" com o modelo atual para tais declarações.

Há então uma vantagem prática do ponto de vista de um escritor compilador. Já existe a máquina em compiladores para executar tipo de dedução para uma chamada de função (que é como auto é descrito como operando). A regra acima é consistente com a regra de que a dedução para um parâmetro de modelo deve resultar no mesmo 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.
}

Uma implementação fácil para auto é reutilizar os mecanismos existentes para deduzir o tipo de auto , e por causa da consistência com comportamentos atuais o resultado não vai ser muito surpreendente para as pessoas.

Finalmente, e esta é provavelmente o ponto mais importante na minha opinião. O modelo atual é conservadora e funciona de forma muito semelhante a construções de linguagem existentes em C ++. Portanto, as chances de ele resultando em um erro linguagem show de parada são muito escassas. No entanto, o modelo atual pode facilmente ser expandido no futuro para conter os outros exemplos que você lista em sua pergunta.

Além do mais, que a expansão não vai quebrar o código que utiliza a actual redacção do auto . Considere se eles fizeram isso de outra maneira. Se a versão expandida do auto foi a primeira versão, e isso resultou em alguma falha estranho e fatal com a palavra-chave, em seguida, uma vez que exigiria a remoção de um recurso de linguagem a partir do padrão - algo que quase nunca acontece como é mais provável código breaks.

Answer 4

O primeiro seria o tipo de linha-se com a forma como a inferência de tipos funciona no tipo de retorno do:?. Operador