const方法中decltype的结果

Question

The C++11 decltype returns the type of the expression given to it (mostly). But this can differ from the type of the expression as it is actually accessible:

template<typename T>
struct Ref {
    Ref(T&) { }
};

#define GETTYPE decltype
//#define GETTYPE typeof

struct Problem {
    void doit_c() const { Ref<GETTYPE(n)> rn{n}; }
    void doit_nc()      { Ref<GETTYPE(n)> rn{n}; }
    int n;
};

int main() {
    int i;
    const int ci = 0;
    Problem pr;

    // decltype == typeof == int
    Ref<GETTYPE(i)> ri{i};
    pr.doit_nc();

    // decltype == typeof == const int
    Ref<GETTYPE(ci)> rci{ci};
    Ref<GETTYPE(static_cast<const int&>(i))> rcci{static_cast<const int&>(i)};

    // typeof == const int, decltype == int (!)
    pr.doit_c();

    return 0;
}

In the example, the Ref struct is just used to cause a compile error if T does not match the actual constructor argument. The Problem::doit_c() method is where decltype(n) returns a non-const result, even though n is const in this context.

If one switches from the standard decltype to the GNU extension typeof , this seems to take the const-ness of the method into account.

Now my question: Is there a C++11 / C++14 / C++17 compliant alternative to decltype() / typeof() that behaves "correctly" (as in: no compile error above) for expressions like the declaration in the const-method above?

Edited:

• Simplified the first sentence to remove some errors and stop distracting from the point of the question (thanks, @skypjack)

• Simplified the use use of macros in the example code (thanks, @Richard Critten)

Answer 1

decltype is a feature that kinda sits at two chairs at once. Firstly, as the name suggests, it can give you the exact declared type of an entity, ignoring the context in which it is used. Secondly, it can treat its argument as an expression, whose exact type depends on the context and its value category.

decltype applied directly to a "naked" (unparenthesized) class member access is a special case, in which decltype acts in accordance with its first role. It will not treat n as an expression. Instead it will produce the type of that class member, ignoring the context.

If you want it to treat n as an expression, you have to parenthesize it

struct Problem {
  void doit_c() const 
  { 
    Ref<decltype(n)> rn1{n}; // `decltype(n)` is `int` -> ERROR
    Ref<decltype((n))> rn2{n}; // `decltype((n))` is `const int &` -> compiles OK
  }
};

Answer 2

You can find out the effective cv-qualified type of n using a temporary reference:

void doit_c() const { auto& x = n; Ref<GETTYPE(x)> rn{n}; }
void doit_nc()      { auto& x = n; Ref<GETTYPE(x)> rn{n}; }

But it's simpler and clearer to parenthesize, as shown in AnT's answer .