C ++ decltype e parênteses - por quê?

O assunto foi discutido antes , mas isso não é uma duplicata.

Quando alguém pergunta sobre a diferença entre decltype(a)e decltype((a)), a resposta usual é - aé uma variável, (a)é uma expressão. Acho esta resposta insatisfatória.

Primeiro, aé uma expressão também. As opções para uma expressão primária incluem, entre outras -

• (expressão)
• expressão id

Mais importante, o fraseado para decltype considera parênteses muito, muito explicitamente :

For an expression e, the type denoted by decltype(e) is defined as follows:
(1.1)  if e is an unparenthesized id-expression naming a structured binding, ...
(1.2)  otherwise, if e is an unparenthesized id-expression naming a non-type template-parameter, ...
(1.3)  otherwise, if e is an unparenthesized id-expression or an unparenthesized class member access, ...
(1.4)  otherwise, ...

Então a questão permanece. Por que os parênteses são tratados de maneira diferente? Alguém está familiarizado com documentos técnicos ou discussões de comitês por trás disso? A consideração explícita entre parênteses leva a pensar que isso não é um descuido, então deve haver uma razão técnica que me falta.

Não é uma supervisão. É interessante que em Decltype e auto (revisão 4) (N1705 = 04-0145) exista uma declaração:

As regras decltype agora declaram explicitamente isso decltype((e)) == decltype(e)(conforme sugerido pelo EWG).

Mas no Decltype (revisão 6): redação proposta (N2115 = 06-018), uma das mudanças é

A expressão entre parênteses dentro de decltype não é considerada um id-expression.

Não há justificativa na redação, mas suponho que essa seja uma extensão do tipo de declty usando uma sintaxe um pouco diferente; em outras palavras, ele pretendia diferenciar esses casos.

O uso para isso é mostrado no C ++ draft9.2.8.4:

const int&& foo();
int i;
struct A { double x; };
const A* a = new A();
decltype(foo()) x1 = 17;        // type is const int&&
decltype(i) x2;                 // type is int
decltype(a->x) x3;              // type is double
decltype((a->x)) x4 = x3;       // type is const double&

O que é realmente interessante, é como ele funciona com a returndeclaração:

decltype(auto) f()
{
    int i{ 0 };
    return (i);
}

Meu Visual Studio 2019 sugere que eu remova parênteses redundantes, mas na verdade eles se transformam em decltype((i))quais alterações retornam valor para o int&que o torna UB desde que retornaram referência a uma variável local.

Por que os parênteses são tratados de maneira diferente?

Parênteses não são tratados de maneira diferente. É a expressão de identificação não parênteses que é tratada de maneira diferente.

Quando os parênteses estão presentes, as regras regulares para todas as expressões se aplicam. O tipo e a categoria de valor são extraídos e codificados no tipo dedecltype .

A provisão especial existe para que possamos escrever código útil com mais facilidade. Ao aplicar decltypeao nome de uma variável (membro), geralmente não queremos um tipo que represente as propriedades da variável quando tratada como uma expressão. Em vez disso, queremos apenas o tipo com o qual a variável é declarada, sem ter que aplicar uma tonelada de características de tipo para chegar a ela. E é exatamente isso que decltypeé especificado para nos dar.

Se nos importamos com as propriedades da variável como uma expressão, ainda podemos obtê-la com bastante facilidade, com um par extra de parênteses.

Antes do C ++ 11, a linguagem precisa de ferramentas para obter dois tipos diferentes de informações :

• o tipo de uma expressão
• o tipo de uma variável como foi declarada

Devido à natureza dessas informações, os recursos tiveram que ser adicionados no idioma (isso não pode ser feito em uma biblioteca). Isso significa novas palavras-chave. O padrão poderia ter introduzido duas novas palavras-chave para isso. Por exemplo, exprtypepara obter o tipo de uma expressão e decltypeobter o tipo de declaração de uma variável. Essa teria sido a opção clara e feliz.

No entanto, o comitê padrão sempre se esforçou ao máximo para evitar a introdução de novas palavras - chave no idioma para minimizar a quebra do código antigo. A compatibilidade com versões anteriores é uma filosofia central do idioma.

Assim, com C ++ 11 nós temos apenas uma palavra-chave usada por duas coisas diferentes: decltype. A maneira como diferencia os dois usos é tratando de maneira decltype(id-expression)diferente. Foi uma decisão consciente do comitê, um (pequeno) compromisso.