当方法没有参数时，通过引用返回对象（例如，std::string）有什么意义吗？

Question

Take the following snippet of code

 #include <iostream>
 #include <string>
  
 class Foo {
 private:
     std::string m_name;
     
 public:
     Foo(std::string name) : m_name { name } {}
     const std::string & get_name() const { return m_name; } 
 };
 
 int main() {
     Foo x { "bob" };
     x.get_name();
 }

Because I initialized an object and name exists somewhere in memory, is a temporary object is made when I call the x.get_name() ? If a temporary object is made, than is there a point to returning by reference? My understanding is you return by reference so to avoid the cost of creating a large object or when using an std::ostream& object because you have to.

Answer 1

Yes, there is a point, you return by reference if you want to return a reference to some object.

Why would you want to have a reference to some object? Exactly because you need to access it and not a copy of it . Reasons might vary, basic ones are that you do not want to make an extra copy - eg the get_name you posted, maybe you want to store it and access it later, and/or because you want to modify it.

Returning a reference is not much different from a passing parameter by reference.

No temporary std::string object is made in x.get_name() . The method returns lvalue reference by value. Since references are usually implemented as pointers, the true return value is a pointer. So a copy of the pointer is made during each call but that is like returning an int - can be done in registers or stack. So it's as cheap as it gets.

Yes, your understanding is correct, although I would say that const T& is used when we want to avoid copy for whatever reasons and T& should only be used when we need to get mutable access to the object - eg std::ostream& in operator<< which mutates the stream by printing into it.

BTW, you make an extra copy in your ctor - name parameter is copied into name member. Instead you should move it there like Foo(std::string name):name(std::move(name)){} .