如何使用带模板的类成员的尾随返回类型

Question

I'm trying to implement the following class:

template <typename Container>
class reverse_adaptor
{
public: // Construction
    reverse_adaptor(Container &container) :
        m_container(container)
    {}

public: // STL container static polymorphism
    auto begin() const -> decltype(m_container.rbegin())
    {
        return m_container.rbegin();
    }

    auto end() const -> decltype(m_container.rend())
    {
        return m_container.rend();
    }

private: // Members
    Container &m_container;
};

The reason I'm using the trailing return type is because I don't know if m_container will be const or not, so I let the compiler work it out for me. However, I'm getting the following compiler errors:

/Users/mark/Blah/Stdx.h:77:40: No member named 'm_container' in 'stdx::reverse_adaptor > >'

I thought it might be related to the multi-stage pass of templated types, so changed it to read decltype(this->m_container.rbegin()) , but that didn't work either.

How can I get this to work?

Example - http://ideone.com/ekVYlH

Answer 1

The trailing-return-type of a function is part of its “ signature ” (declaration), not of its “body” (definition), and as such, it only sees names that were declared before .

At the point where you declare your begin member function, m_container hasn't been declared yet. (Note that the issue is not specific to template classes.)

• You could move the declaration of m_container up in the class definition (but it forces you to put private members before public interface, which is contrary to common practice...).

• You can work-around with declval : replace m_container with std::declval<Container&>() inside the decltype : http://ideone.com/aQ8Apa

(As said in the comments, in C++14 you'll be able to drop the trailing return type and just use decltype(auto) as the “normal” return type.)

---

Addendum: As for why you can use not-yet-declared members inside the in-class body of a member function but not in the trailing return type, it's because the following:

class Foo {
public:
    auto data() const -> decltype(m_data)
    {
        return m_data;
    }
private:
    SomeType m_data;
};

will be _{[disclaimer: informal wording!]} kind of “rewritten by the compiler” into something equivalent to this:

class Foo {
public:
    inline auto data() const -> decltype(m_data); // declaration only
private:
    SomeType m_data;
};

// at this point, all members have been declared

inline auto Foo::data() const -> decltype(m_data) // definition
{
    return m_data;
}

where a name cannot be used before its declaration (which the first decltype(m_data) violates).

Answer 2

The name m_container has not been introduced at the point the functions are declared . Switch the order of declarations, and the code will work.

See working version here .