Reading the answer for one exercise in C++ Primer, 5th Edition, I found this code:
#ifndef CP5_ex7_04_h #define CP5_ex7_04_h #include <string> class Person { std::string name; std::string address; public: auto get_name() const -> std::string const& { return name; } auto get_addr() const -> std::string const& { return address; } }; #endif What does
const -> std::string const& mean in this case?
auto get_name() const -> std::string const& { return name; } is trailing return type notation for the equivalent
std::string const& get_name() const { return name; }
Note that the equivalence is exact in the sense that you can declare a function using one syntax and define it with the other.
(This has been part of the C++ standard since and including C++11).
auto main() -> int {} wherever Alf writes a C++ answer on SO ;)
std::string const& get_name() const; The purpose of the new syntax is to have more names in lexical scope while the return type is processed, which is handy when using decltype.main, and off the top of my head I'm not sure why that is (I'd be tempted to say it's actually a compiler bug, but neither brand new clang nor brand new GCC are happy with it; I have asked SO for advice). Obviously if you omitted return 0 like a good boy then it would all be moot anyway ;)The part -> std::string const& is trailing return type and is new syntax since C++11.
The first const says it a const member function. It can be safely called on a const object of type Person.
The second part simply tells what the return type is - std:string const&.
It is useful when the return type needs to be deduced from a template argument. For known return types, it is no more useful than than using:
std::string const& get_name() const { return name; } It all makes more sense when you see an example where it actually matters; as written in the question, it's just an alternative way to declare the return type.
If you have a template function where you can not know the return type in advance, this can actually help. For example:
template <class X, class Y> auto DoSomeThing(X x, Y y) -> decltype(x * y); You don't know what types X and Y actually are but you know the return value will have the same type as x * y which can be deduced in this way.
const is a cv-qualifier of the usual kind for the member function : *this is const inside the function.
-> std::string const& pairs with auto to form a trailing return type (see (2)). The difference is only syntactic here -- the following syntax is equivalent:
std::string const& get_name() const { return name; } 
auto func() -> type=type func(), but the first one has more features. In your case it has no advantages and was probably used because someone who wrote the code likes it more than the normal syntax.