Pro's and Con's of returing references

I've recently began working on a moderate size C++ application. The previous developer loved the benefits of returning const&.

For those who don't know returning const& can avoid an extraneous copy. Example:

class Foo {
  Foo(std::string s) { m_name = s; }
  std::string m_name;
public:
  std::string const& name() { return m_name; }
}

The above code avoids the copy from m_name to the function return value that would have resulted with the following client code:

  Foo f("bar"); 
  std::string name = f.name(); 

After working in this code base for a while now I believe that returning references are evil and should be treated just like returning a pointer, which is avoid it.

For example the problem that arose that took a week to debug was the following:

  class Foo {
    std::vector< Bar > m_vec;
  public:
    void insert(Bar& b) { m_vec.push_back(b); }
    Bar const& getById(int id) { return m_vec[id]; }
  }

The problem in this example is clients are calling and getting references that are stored in the vector. Now what happens after clients insert a bunch of new elements? The vector needs to resize internally and guess what happens to all those references? That's right there invalid. This caused a very hard to find bug that was simply fixed by removing the &.

The conclusion I've arrived at is that returning a & is a pre-mature optimization. If your profiling shows you your code is very slow at this point than maybe consider it. But you should also be aware that most modern compilers optimize away this extra copy anyways.

Here is a contrived example that shows problems you can get into by blindly returning references. My advice avoid them until your profiler tells you that you have a problem.

#include 
#include 
#include 

using namespace std;

class foo {
    std::string m_string;
    public:
    std::string const  getName(){
       static int count = 0;
       count++;
       std::stringstream ss;
       ss << count ;
       m_string = ss.str();
       return m_string;
    }
};
foo f;
void fun(std::string const&s) {
    f.getName();
    std::cout << s;
}
int main() {
    std::cout << " print version " << std::endl;
    fun(f.getName());
}

Hope that Helps