Sobrecarga de operador: função de membro vs. função de não membro?

Eu li que um operador sobrecarregado declarado como função de membro é assimétrico porque pode ter apenas um parâmetro e o outro parâmetro passado automaticamente é o thisponteiro. Portanto, não existe um padrão para compará-los. Por outro lado, o operador sobrecarregado declarado como a friendé simétrico porque passamos dois argumentos do mesmo tipo e, portanto, eles podem ser comparados.

Minha pergunta é que, quando ainda posso comparar o lvalue de um ponteiro com uma referência, por que os amigos são preferidos? (usar uma versão assimétrica dá os mesmos resultados que simétrica) Por que os algoritmos STL usam apenas versões simétricas?

Se você definir sua função sobrecarregada de operador como função de membro, o compilador traduzirá expressões como s1 + s2em s1.operator+(s2). Isso significa que a função de membro sobrecarregada do operador é chamada no primeiro operando. É assim que funcionam as funções de membro!

Mas e se o primeiro operando não for uma classe? Há um grande problema se quisermos sobrecarregar um operador onde o primeiro operando não é um tipo de classe, digamos double. Então você não pode escrever assim 10.0 + s2. No entanto, você pode escrever função de membro com sobrecarga de operador para expressões como s1 + 10.0.

Para resolver esse problema de ordenação , definimos a função sobrecarregada do operador como friendSE ela precisa acessar os privatemembros. Faça-o friendSOMENTE quando precisar acessar membros privados. Caso contrário, simplesmente torne -a uma função não-membro não-amiga para melhorar o encapsulamento!

class Sample
{
 public:
    Sample operator + (const Sample& op2); //works with s1 + s2
    Sample operator + (double op2); //works with s1 + 10.0

   //Make it `friend` only when it needs to access private members. 
   //Otherwise simply make it **non-friend non-member** function.
    friend Sample operator + (double op1, const Sample& op2); //works with 10.0 + s2
}

Leia estes:
Um pequeno problema de ordenação de operandos
Como funções de não membros melhoram o encapsulamento

Não é necessariamente uma distinção entre friendsobrecargas de operador e sobrecargas de operador de função de membro, pois é entre sobrecargas de operador global e sobrecarga de operador de função de membro.

Uma razão para preferir um mundial sobrecarga de operador é se você quiser permitir que expressões onde o tipo de classe aparece no direito lado de um operador binário. Por exemplo:

Foo f = 100;
int x = 10;
cout << x + f;

Isso só funciona se houver uma sobrecarga de operador global para

Operador Foo + (int x, const Foo & f);

Observe que a sobrecarga do operador global não precisa necessariamente ser uma friendfunção. Isso só é necessário se precisar de acesso a membros privados de Foo, mas nem sempre é o caso.

Independentemente disso, se Footivesse apenas uma sobrecarga de operador de função de membro, como:

class Foo
{
  ...
  Foo operator + (int x);
  ...
};

... então, só poderíamos ter expressões em que uma Fooinstância apareça à esquerda do operador mais.