Why Does Using Double Parentheses in `decltype` Change the Resulting Type?

Type Deduction with Double Parentheses in decltype

In C , the decltype keyword can be used to determine the type of an expression. When used with double parentheses, it exhibits a subtle behavior that can lead to confusion.

Problem:

Consider the following code snippet:

<code class="cpp">const int&&& foo();
int i;
struct A { double x; };
const A* a = new A();
decltype(foo()) x1 = i;     // 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&</code>

Why does adding parentheses to a->x in the fourth line change the resulting type from double to const double&?

Answer:

The explanation lies in the rules for deducing types using decltype. According to the C language standard:

1. If e is an unparenthesized identifier or a class member access, decltype(e) returns the type of the entity named by e.
2. If e is an lvalue, decltype(e) returns T&, where T is the type of e.

In the given example:

• decltype(a->x) interprets a->x as a class member access, resulting in a type of double.
• decltype((a->x)) interprets (a->x) as an lvalue, resulting in a type of const double&.

Therefore, adding parentheses to a->x changes the type deduction from the type of the member accessed to a reference to the member itself.

The above is the detailed content of Why Does Using Double Parentheses in `decltype` Change the Resulting Type?. For more information, please follow other related articles on the PHP Chinese website!