C++ Auto Return Type – Using ‘auto’ Return Type in Class Members

autoc++c++14class

How can automatic type deduction be used for class members? For example, the following code

struct A
{
  auto foo(); // foo is defined in another file 
};


int main()
{
  A a;
  a.foo();
}

where foo has the return type auto results in the following error:

error: function 'foo' with deduced return type cannot be used before it is defined
  a.foo();
    ^

The error is comprehensible since the compile cannot know what foo's return type is without knowing its definition.

My question is, if there is any workaround or some kind of programming pattern to circumvent the problem that auto return type cannot be used for class member functions, in case that the function's declaration and definition is separated.

Best Answer

If you want to use return type deduction, you cannot separate the declaration and definition into different files (not unless everyone includes both). There's no workaround for this other than to use an actual type.

When C++ goes to compile code that calls func, it must be able to know, at that time, what it will return. Without having definition in that translation unit, the compiler cannot know what will be returned. And therefore, the compiler cannot compile that code. And C++'s compilation model does not allow it to use information from other translation units in this way.

The best you might be able to do is wait for modules, which may be able to get around this.

Don't think of return type deduction as a way to never have to write return types. It's a feature intended for circumstances where the return type is awkward to write, where the most reasonable way to write it is as a decltype(expr), and expr is the exact expression you're going to return. And those cases are typically in template code, which has to go into headers anyway. If the return type is simple and obvious to you, there's really little reason not to put it there. Don't use return type deduction by default.

Related Solutions

C++11 Auto and Function Return Types – Comprehensive Guide

The rules for auto are the same as for template type deduction:

template <typename T>
void f(T t); // same as auto
template <typename T>
void g(T& t); // same as auto&
template <typename T>
void h(T&& t); // same as auto&&

std::string sv;
std::string& sl = sv;
std::string const& scl = sv;

f(sv); // deduces T=std::string
f(sl); // deduces T=std::string
f(scl); // deduces T=std::string
f(std::string()); // deduces T=std::string
f(std::move(sv)); // deduces T=std::string

g(sv); // deduces T=std::string, T& becomes std::string&
g(sl); // deduces T=std::string, T& becomes std::string&
g(scl); // deduces T=std::string const, T& becomes std::string const&
g(std::string()); // does not compile
g(std::move(sv)); // does not compile

h(sv); // deduces std::string&, T&& becomes std::string&
h(sl); // deduces std::string&, T&& becomes std::string&
h(scl); // deduces std::string const&, T&& becomes std::string const&
h(std::string()); // deduces std::string, T&& becomes std::string&&
h(std::move(sv)); // deduces std::string, T&& becomes std::string&&

In general, if you want a copy, you use auto, and if you want a reference you use auto&&. auto&& preserves the constness of the referene and can also bind to temporaries (extending their lifetime).

C++11 Auto Keyword – How to Return Arbitrary Type Using Auto

The C++11 version of auto as return type only allows you to postpone the return type declaration until after the function parameters have been declared:

template<typename T1, typename T2>
auto add(T1 x, T2 y) -> decltype(x + y) { return x + y; }

Here you can't write decltype(x + y) add(...) because the compiler doesn't know what x and y are.

The C++14 version of auto permits return type deduction by the compiler. It tells the compiler to deduce the return type of the function based on the body, but it's still a single return type, so it still does not do what you want.

Best Answer

Related Solutions

C++11 Auto and Function Return Types – Comprehensive Guide

C++11 Auto Keyword – How to Return Arbitrary Type Using Auto

Related Question