operator < debe tomar exactamente un argumento

Una función amiga no es una función miembro, por lo que el problema es que declaras operator<< como amigo de A:

 friend ostream& operator<<(ostream&, A&);

Luego intenta definirla como una función miembro de la clase logic

 ostream& logic::operator<<(ostream& os, A& a)
          ^^^^^^^

¿Está confundido acerca de si logic es una clase o un espacio de nombres?

El error se debe a que ha intentado definir un miembro operator<< tomando dos argumentos, lo que significa que toma tres argumentos incluyendo el parámetro implícito this. El operador solo puede tomar dos argumentos, por lo que que cuando escribes a << b los dos argumentos son a y b.

Desea definir ostream& operator<<(ostream&, const A&) como una función no miembro, definitivamente no como miembro de logic ya que no tiene nada que ver con esa clase!

std::ostream& operator<<(std::ostream& os, const A& a)
{
  return os << a.number;
}

Me encontré con este problema con las clases templadas. Aquí hay una solución más general que tuve que usar:

template class <T>
class myClass
{
    int myField;

    // Helper function accessing my fields
    void toString(std::ostream&) const;

    // Friend means operator<< can use private variables
    // It needs to be declared as a template, but T is taken
    template <class U>
    friend std::ostream& operator<<(std::ostream&, const myClass<U> &);
}

// Operator is a non-member and global, so it's not myClass<U>::operator<<()
// Because of how C++ implements templates the function must be
// fully declared in the header for the linker to resolve it :(
template <class U>
std::ostream& operator<<(std::ostream& os, const myClass<U> & obj)
{
  obj.toString(os);
  return os;
}

Ahora: * Mi función toString () no puede estar en línea si va a estar escondida en cpp. * Estás atascado con algún código en el encabezado, no pude deshacerme de él. * El operador llamará al método toString (), no está inlineado.

El cuerpo del operador

Tal vez estoy entendiendo mal o falta algo, pero simplemente declarar hacia adelante la plantilla del operador no se vincula en gcc.

Esto también funciona:

template class <T>
class myClass
{
    int myField;

    // Helper function accessing my fields
    void toString(std::ostream&) const;

    // For some reason this requires using T, and not U as above
    friend std::ostream& operator<<(std::ostream&, const myClass<T> &)
    {
        obj.toString(os);
        return os;
    }
}

Creo que también puede evitar los problemas de plantillas forzando declaraciones en encabezados, si usa una clase padre que no está templada para implementar operator