std::ostream& operator<<(std::ostream& ostr, const ArgumentParser& ap)
{
  std::string arguments = "Argument Parser: ";
  for(unsigned int i = 0 ; i <  ap.arguments.size() ;i++){
      arguments += ap.arguments[i]->getArgument() + " ";
    }

  return ostr <<  arguments << std::endl;
}

bool NonAtomicArgument::operator==(const std::string s) const
{

    return name == s;
}

Schonmal danke
Ich hoffe das die Frage verständlich ist!

struct foo{};
void operator+(foo&, foo&) {};

int main
{
  foo a,b;
  operator+(a,b);
  // ist das gleiche wie
  a + b;
}

manusic schrieb:

Also ist es im ersten Falle des Ausgabeoperators so das ich den Ausgabeoperator des ostreams überlade?

Um es mal ganz genau zu formulieren: Du deklarierst eine freie Funktion, die heißt operator<<, die gehört zu gar keiner Klasse. Diese Funktion nimmt zwei Argumente, und zwar linksseitig eine ostream& und rechtsseitig ein Objekt deiner Klasse. Die Funktion gehört aber zu keiner dieser Klassen.
Da es schon eine ganze Reihe anderer Funktionen dieses Namens mit jeweils anderen Parametern gibt, hast du also eine weitere Überladung dieser Funktion hinzu gefügt.

Und im zweiten Falle so das ich einen ==Operator definiere der vorher in der eigenen Klasse garnicht vorhanden war?

Du deklarierst eine Memberfunktion der Klasse, die den Namen operator== hat. Wenn es vorher noch keine Memberfunktion dieser Klasse mit diesem Namen gab, dann ist sie neu, ansonsten ist es einer weitere Überladung einer Funktion dieses Namens und muss sich in ihrer Signatur von den anderen Funktion dieses Namens unterscheiden. Es ist aber durchaus möglich, mehrere Überladungen dieser Funktion zu haben.

Danke ich glaube das verstehe ich aber wäre es denn auch möglich eine Funktion mit dem <<operator zu schreiben die zur Klasse gehört oder macht das keinen Sinn?

Doch das macht Sinn.
Die Aufrufsyntax wäre in diesem Fall:

obj.operator<<(arg);

bzw.

obj << arg;

Um beim ostream zu bleiben:

foo << std::cout;

Was dann doch eher unintuitiv ist.