Ich habe mich in den letzten Stunden durch einige Foren gewühlt, um in einem Programm, dass ich gerade schreibe, den <<-Operator für ein Objekt einer eigenen Klasse verwenden zu können. Nun, nachdem ich stundenlang das "operator<<(std::ostream&, const Spielkarte&)' must take exactly one argument" auszumerzen probiert habe (hat auch geklappt), besteht nun ein anderes Problem, das mich wahnsinnig macht...
Aber hier zuerst der relevante Code.

Spielkarte.h

#ifndef SPIELKARTE_H
#define SPIELKARTE_H

#include <string>

using namespace std;

class Spielkarte
{
      public: enum Kartentyp
              {
                   GOTT,
                   ELEMENT,
                   MOB,
                   TOD,
                   KRIEG,
                   CHARAKTER
              };

              Spielkarte(string name, Kartentyp typ, string beschreibung);
              Spielkarte();
              ~Spielkarte();

              string name;
              Kartentyp typ;
              string beschreibung;

      friend ostream& operator<< (ostream &out, const Spielkarte &karte);
};

#endif

Spielkarte.cpp

#include "Spielkarte.h"

Spielkarte::Spielkarte(string name, Kartentyp typ, string beschreibung)
{
     this->name = name;
     this->typ = typ;
     this->beschreibung = beschreibung;
}

Spielkarte::Spielkarte()
{
}

Spielkarte::~Spielkarte()
{
}

ostream& operator<< (ostream &out, const Spielkarte &karte)
{
     out << karte.name << ", " << karte.typ << ", " << karte.beschreibung;

     return out;
}

Das Problem sieht mein Compiler (Dev-C++ mit mingw) in der zuletzt aufgeführten Funktion operator<<
In function `std::ostream& operator<<(std::ostream&, const Spielkarte&)':
20: no match for 'operator<<' in 'std::operator<< [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((std::basic_ostream<char, std::char_traits<char> >&)(+out)), ((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)((const std::string*)karte))) << ", "'
19: note: candidates are: std::ostream& operator<<(std::ostream&, const Spielkarte&)

Wenn ich das also gerade richtig verstehe, probiert er meinen soeben definierten Operator << anzuwenden... anstatt eines einfachen Operators, wie er halt benutzt wird.

Also habe ich mal ein bisschen mit Zeile 20 rumgespielt und folgendes hinbekommen:

Wenn ich in Zeile 20 nur

out << karte.name;

schreibe, gehts.
Auch wenn ich

out << karte.beschreibung;

schreibe, funktioniert es.

Doch sobald ich den enum oder auch nur so ein einfaches string-Konstrukt wie ", " (zur Abtrennung der einzelnen Werte) einbaue, geht das Ganze höllisch schief.

Liebe Community:

Woran liegt dies?

Oder liegt doch ein Compilerproblem vor, sodass Dev-C++ Schuld ist?

Ich danke euch für Hilfe ._.

Oder liegt doch ein Compilerproblem vor, sodass Dev-C++ Schuld ist?

Sorry, ich bin zu müde um jetzt den Rest durchzulesen, aber Dev-C++ solltest du wechseln (Kostenlose, aktuelle Alternativen sind u.a. Visual C++ Express 2008 oder Code::Blocks).

Woran liegt dies?

Oder liegt doch ein Compilerproblem vor, sodass Dev-C++ Schuld ist?

An dir ;).

Ich habe dir deinen Quelltext etwas umgeschrieben, ein paar Kleinigkeiten hinzugefügt, weggelassen.

Sieh dir am besten mal die Unterschiede an. Wenn du Fragen hast, suche zuerst hier im Forum. Es gibt einen hervoragenden Beitrag zum Thema Operatorüberladung, weshalb ich das hier nicht erneut anspreche.

Weitere interessante Themen sind (auf deinen Post bezogen):

• struct, class, union
• namespaces und wann man using vermeiden sollte
• Konstruktoren, Funktionen mit Default-Parametern
• Konstruktoren und Intitialisierungslisten
• Friends und wann man sie nicht benötigt

<<main.cc>>

#include "spielkarte.h"
#include <iostream>
using namespace std;

int main()
    {
        using namespace cppde;
        Spielkarte karte(Spielkarte::ELEMENT, "Wasser", "Blubb");
        cout << karte << endl;
    }

<<spielkarte.h>>

#if !defined(CPPDE_SPIELKARTE_H__INCLUDED)
#define CPPDE_SPIELKARTE_H__INCLUDED

#include <string>
#include <ostream> // casus knackus

namespace cppde {

struct Spielkarte
{
    enum Typ { NONE, GOTT, ELEMENT, MOB, TOD, KRIEG, CHARAKTER };

    Typ typ;
    std::string name;
    std::string beschreibung;

    Spielkarte(Typ typ=NONE, const std::string& name="",
               const std::string& beschreibung="");
};

} // -- namespace cppde --

std::ostream& operator<<(std::ostream& out, const cppde::Spielkarte& karte);

#endif

<<spielkarte.cc>>

#include "spielkarte.h"
using namespace cppde;
using std::string;
using std::ostream;

Spielkarte::Spielkarte(Typ typ, const string& name, const string& beschreibung)
    : typ(typ), name(name), beschreibung(beschreibung)
    { }

ostream& operator<<(ostream& out, const Spielkarte& karte)
    {
        out << karte.name << ", " << karte.typ << ", " << karte.beschreibung;
        return out;
    }

Grüße ... Heiko

Ansonsten (zum Ursprungspost):
BITTE keine "using namespace XYZ;" im Header! Damit wird in jeder Datei, wo dein Header includet wird, der Namespace komplett sichtbar und du kannst voll in Namenskollisionen laufen - und brauchst ewig herauszufinden warum