如何从类中获取成员函数的返回类型？

Question

The following program yields a compilation error with clang , though it passes on other compilers:

#include <utility>

struct foo
{
  auto bar() -> decltype(0)
  {
    return 0;
  }

  using bar_type = decltype(std::declval<foo>().bar());
};

int main()
{
  return 0;
}

clang yields:

$ clang -std=c++11 clang_repro.cpp 
clang_repro.cpp:10:48: error: member access into incomplete type 'foo'
  using bar_type = decltype(std::declval<foo>().bar());
                                               ^
clang_repro.cpp:3:8: note: definition of 'foo' is not complete until the closing '}'
struct foo
       ^
1 error generated.

Is this program illegal, and if so, is there a correct way to define foo::bar_type ?

clang details:

$ clang --version
Ubuntu clang version 3.5-1ubuntu1 (trunk) (based on LLVM 3.5)
Target: x86_64-pc-linux-gnu
Thread model: posix

Answer 1

g++4.9 issues the same error

I'm not sure if this is an invalid code, because incomplete types are allowed for declval , and expression in decltype is not evaluated.
rightføld in his answer explained very good why this code is invalid.

You can use std::result_of :

using bar_type = std::result_of<decltype(&foo::bar)(foo)>::type;

Which is actually implemented like this:

using bar_type = decltype((std::declval<foo>().*std::declval<decltype(&foo::bar)>())());

The difference between this and the code in the question is that pointer-to-member operator ( .* ) is used instead of member access operator ( . ), and it doesn't require the type to be complete, which is demonstrated by this code:

#include <utility>
struct foo;
int main() {
    int (foo::*pbar)();
    using bar_type = decltype((std::declval<foo>().*pbar)());
}

Answer 2

§7.1.6.2 says:

For an expression e , the type denoted by decltype(e) is defined as follows:

• if e is an unparenthesized id-expression or an unparenthesized class member access (5.2.5), decltype(e) is the type of the entity named by e . …
• …

§5.2.5 says:

For the first option (dot) the first expression shall have complete class type. …

§9.2 says:

A class is considered a completely-defined object type (3.9) (or complete type) at the closing } of the class-specifier. …

decltype(std::declval<foo>().bar()) (and in turn std::declval<foo>().bar() ) appears before the closing } , so foo is incomplete, so std::declval<foo>().bar() is ill-formed, so clang is correct.