In C++, you can overload operators as non-member functions in addition to overloading them as member functions. Overloading operators as non-member functions has a number of benefits over overloading them as member functions, including improved encapsulation and flexibility.

When overloading an operator as a non-member function, the function takes one or two arguments, which correspond to the left and right operands of the operator. The function is defined outside the class definition and is declared as a friend function to have access to the class's private members.

Here is an example of overloading the addition operator (+) as a non-member function:

class MyVector {
public:
    MyVector(int x = 0, int y = 0) : m_x(x), m_y(y) {}

    friend MyVector operator+(const MyVector& left, const MyVector& right) {
        return MyVector(left.m_x + right.m_x, left.m_y + right.m_y);
    }

private:
    int m_x, m_y;
};

In this example, we define a class MyVector that represents a two-dimensional vector. We overload the addition operator as a non-member function, which takes two arguments of type MyVector (the left-hand and right-hand sides of the addition) and returns a new MyVector object that represents the sum of the two vectors.

With the addition operator overloaded as a non-member function, we can now add two MyVector objects using the + operator:

MyVector a(1, 2);
MyVector b(3, 4);
MyVector c = a + b; // Equivalent to c = operator+(a, b);

In this example, we create two MyVector objects a and b, and we add them together using the + operator. The result of the addition is assigned to a third MyVector object c.

Overloading operators as non-member functions can be more flexible than overloading them as member functions, as you can define operator overloads for classes that you do not have control over, or for built-in types. Additionally, overloading operators as non-member functions improves encapsulation, as you do not need to make private members of your class public in order to overload an operator as a member function.

In general, when deciding whether to overload an operator as a member function or a non-member function, consider which approach provides the best encapsulation, readability, and flexibility for your particular use case.