What are the best practices for operator overloading in C++11?

What are the best practices for operator overloading in C++11?

When overloading operators in C++11, it's important to ensure that the behavior is intuitive and consistent. Use member functions for unary operators and non-member functions for binary operators when one of the operands is not of the class type.

Can you give an example of overloading the '+' operator?

Sure! Here's a simple example:

class Complex {
public:
    double real, imag;
    Complex(double r, double i) : real(r), imag(i) {}
    Complex operator+(const Complex& other) {
        return Complex(real + other.real, imag + other.imag);
    }
};

This allows you to add two Complex objects using the '+' operator.

What about the assignment operator?

For the assignment operator, you should implement it as a member function and return a reference to *this. Here's an example:

Complex& operator=(const Complex& other) {
    if (this != &other) {
        real = other.real;
        imag = other.imag;
    }
    return *this;
}

Are there any pitfalls to avoid?

Yes, avoid overloading operators in ways that can confuse users, such as changing the expected behavior of operators. Also, ensure that your overloaded operators maintain consistency with their built-in counterparts.