为人工运算符重载返回引用是否有效？

Question

As we know, we normally return a copy to a new class when overloading an arithmetic operator. As an example, << operator is normally defined like this:

T1 operator<<(const T1& a, const T2& b) {
    // apply b
    return a;
}

But I wonder if it is generally valid to return a reference in this case or not. For example, is it possible that following code creates any invalid situation?

T1& operator<<(T1& a, const T2& b) {
    // apply b
    return a;
}

Why I need this? Let's assume I have a code like this:

class B {
public:
    B() {}
    ~B() { std::cout  << ss_.str() << "\n"; }

    template<typename T>
    B& operator<<(T val) {
        ss_ << val;
        return *this;
    }

private:
    std::stringstream ss_;
};

int main() {
    B{} << "str" << "abc" << 1;
    B{} << "str2" << "abc2" << 2;
}

In this code, constructor and destructor of type T1 will be called only once which will be really suitable here. But if I return by value for the << operator, constructor and destructor will be called for each temporary rvalues which is not great for my use case.

Is it possible that returning by reference create invalid code for overloading these operators?

Answer 1

Yes, it's not only valid, it's a common idiom when overloading << for stream outputs. For example:

std::ostream& operator<<(std::ostream& os, const MyData& data) {
  os << data.a << ',' << data.b << ',' << data.c;
  return os;
}

Answer 2

The rule about returning a reference is to never return a reference to a function local variable. This also includes function parameters that are passed by value.

It gets a little trickier when dealing with reference parameters.

const T1& operator<<(const T1& a, const T2& b) {
    // apply b
    return a;
}

is problematic since a could be bound to a temporary. That would mean that you are returning a reference to an object that is going to end at the end of the full expression the function call is in, which could cause trouble.

Using

T1 operator<<(T1& a, const T2& b) {
    // apply b
    return a;
}

You stop that from happening as now a can only bind to an lvalue so you don't have to worry about it living past the full expression the function is called in.