Is mixing the old and new C++ function syntax in a class allowed?

Question

This code actually works:

class Abstract {
    virtual auto foo() -> int = 0;
};

class Concrete: public Abstract {
    int foo() { cout << "blah!" << endl; return 1; }
} instance;

I understand that the function gets mangled and linked to be the same function signature, but is this kind of mixing actually legal in C++14?

Answer 1

auto foo()->int and int foo() are the same prototype expressed with different syntax, so the second function is an override of the first, and will replace it in runtime dispatch (being virtual) as usually.

The right-side return syntax, has normally another purpose, like

template<class A, class B>
auto some_combination(A a, B b) -> decltype(a+b);

otherwise requiring a more complex syntax like

temlate<class A, class B>
decltype(std::declval<A>()+std::declval<B>()) some_combination(A a,B b);

since a and b are not defined in the left side of the prototype.

When the return type is trivially defined, left or right placement is essentially irrelevant.

Answer 2

It's legal because actually you are fully defining your function.
As a minimal, working example (note the override):

class Abstract {
    virtual auto foo() -> int = 0;
};

class Concrete: public Abstract {
    int foo() override { return 1; }
} instance;

int main() { }

Here the return type isn't deduced, it's explicitly declared by means of a trailing return type.
It's equivalent to:

class Abstract {
    virtual int foo() = 0;
};

It would have been different if you were using this:

class Abstract {
    virtual auto foo() = 0;
};

Here template deduction is involved and virtual functions cannot have deduced return type (that is more or less the error string from GCC).