Should I ever prefer operators overloading over functions/methods?

class T;

// ...

std::ostream & operator<<(std::ostream &os, const T &val)
{
    // ...
    return os;
}

std::cout << "Hello";

operator<<(std::cout, "Hello");

public static Dollar operator +(Euro eu, Dollar dol)
public static Euro operator +(Euro eu, Dollar dol)

// In Dollar
public Dollar Plus(Euro eu)

// In Euro
public Dollar Plus(Dollar dol)

Euro euro00 = new Euro(1);
Dollar dollar00 = new Dollar(1);

Euro sumaEuros = euro00.Plus(dollar00);

public static Dollar operator +(Dollar dol, Euro eu)    
public static Euro operator +(Euro eu, Dollar dol)

Dollar dol1 = ...;
Euro eu1 = ...;

Dollar dol2 = dol1 + eu1;
Euro eu2 = eu1 + do1;

class String {
    // ...
public:
    virtual std::istream& read(std::istream& in);
    virtual std::ostream& write(std::ostream& out) const;
};
std::istream& operator>> (std::istream& in, String& s) {
    return s.read(in);
}
std::ostream& operator<< (std::ostream& out, String const& s) {
    return s.write(out);
}