使用 C++ 尾随返回类型时 auto 的含义是什么？

Question

Instead of usual

void foo (void ) {
    cout << "Meaning of life: " << 42 << endl;
}

C++11 allows is an alternative, using the Trailing Return

auto bar (void) -> void {
    cout << "More meaning: " << 43 << endl;
}

In the latter - what is auto designed to represent?

Another example, consider function

auto func (int i) -> int (*)[10] {

}

Same question, what is the meaning of auto in this example?

Answer 1

In general, the new keyword auto in C++11 indicates that the type of the expression (in this case the return type of a function) should be inferred from the result of the expression, in this case, what occurs after the -> .

Without it, the function would have no type (thus not being a function), and the compiler would end up confused.

Answer 2

Consider the code:

template<typename T1, typename T2>
Tx Add(T1 t1, T2 t2)
{
    return t1+t2;
}

Here the return type depends on expression t1+t2 , which in turn depends on how Add is called. If you call it as:

Add(1, 1.4);

T1 would be int , and T2 would be double . The resulting type is now double (int+double). And hence Tx should (must) be specified using auto and ->

 template<typename T1, typename T2>
    auto Add(T1 t1, T2 t2) -> decltype(t1+t2)
    {
        return t1+t2;
    }

You can read about it in my article .

Answer 3

I think the answer is relatively straightforward, and not covered in other answers here.

Basically, without the auto , there are ambiguities, so The Committee decided "you need auto here to avoid those ambiguities".

class A {
    T B;
};

class B;

A* f();

f()->B;

Now, what does f()->B mean? Is it a function with no parameters that returns a B (with trailing return type syntax), or is it a function call to A* f() ?

If we didn't have the auto required at the start of the trailing return type syntax, we wouldn't be able to tell. With the auto , it's clear that this is a function call.

So, to avoid the unclearness here, we simply require auto at the start of any function declaration that uses a trailing return type.