ich habe eine Klasse geschrieben die einen enum-Ersatz bieten soll. Zusätzlich gehört zu jeden Typ ein string und ein integer-Bereich. Nun möchte ich den operator== der Klasse so überladen, dass ich sie mit einem int vergleichen kann. Auch möchte ich den operator<< für den stringstream überladen. Ich habe zwar jetzt den Code für die Überladung geschrieben, allerdings behauptet der Compiler standhaft, dass er keine Kandidaten für einen Vergleich mit einem int oder einer Benutzung der Klasse im stringstream findet. Mehr oder weniger hab ich den Verdacht das so ziemlich die meisten Operatoren die versucht habe zu überladen, nicht funktionieren.
Ich hab unten das header-file angehängt, im cpp ist nur die Initialisierung der static Variablen sonst nichts.
Kann mir jemand sagen was ich falsch mache?
Danke,
Andreas

#include <map>
#include <sstream>
#include <ostream>
#include <string>

class verbose_action {
private:

	enum m_verbose_action{
		m_TRACE_EXECUTION,
		m_TRACE_NUMBER,
		m_INTERRUPT,
                // weitere enums ...
	};

	m_verbose_action m_action;

	string m_action_name;

	static map<string, m_verbose_action> actions;

	verbose_action(m_verbose_action action, char *action_name){
		m_action = action;
		m_action_name = string(action_name);

		actions[m_action_name] = m_action;

	}

public:
	verbose_action(const verbose_action& action):       
                        m_action(action.m_action),
	 		m_action_name(action.m_action_name){}

	string get_string() const {
		return m_action_name;
	}

	verbose_action &operator=(const string &name){
		m_action = actions[name];
		m_action_name = name;
		return *this;
	}

	verbose_action &operator=(char *name){
		m_action = actions[string(name)];
		m_action_name = string(name);
		return *this;
	}

	bool operator==(const verbose_action &action){
		return (m_action == action.m_action);
	}

	ostream &operator<<(ostream &target){
		target << m_action_name;
		return target;	
	}

	stringstream &operator<<(stringstream &target){
		target << m_action_name;
		return target;	
	}

	bool operator==(const int& test) const{
		// zum testen soll einfach mal nur true zurück
                // gegeben werden
                return true;	
	}

	static const verbose_action TRACE_EXECUTION;
	static const verbose_action TRACE_NUMBER;
	static const verbose_action INTERRUPT;

};

Ja so ist es. Aber ich habe keine Ahnung was ein: "kick-delete-createnew-zyklus mit macro-art remebering" ist.

ich muss jetzt weg. es wird anderen wie TGGC eine freude sein, dir bei der verbesserung der klasse behilfreich zu sein.

Aber viel dringlicher ist die Operatorüberladung weil ich die Klasse leider vorschnell im ganzen Source eingesetzt habe und nun gar nichts mehr geht!!

ungetestet:

friend bool operator==(verbose_action const& a,verbose_action const& b){
		return a.m_action == action.m_action;
	}
	friend bool operator==(verbose_action const& a,int b){
		return int(a.m_action) == action.m_action;
	}
	friend bool operator==(int a,verbose_action const& b){
		return a.m_action == int(action.m_action);
	}

	friend ostream &operator<<(ostream &target,verbose_action a){
		target << a.m_action_name;
		return target;	
	}

	//stringstream &operator<<(stringstream &target)//weg, ist ja schon in ostream

Über das "kick-delete-createnew-zyklus mit macro-art remebering" würde ich natürlich auch noch gerne aufgeklärt werden.

Danke! Das funktioniert super, jetzt würde ich mich aber auch noch über eine Erklärung freuen, warum meine Version der Operatorüberladung nicht funktioniert!

Bei den Streamoperatoren muss der Stream der linke Operand sein, und das auszugebende Objekt der rechte. Bei Memberoperatoren ist aber immer die enthaltende Klasse der linke Operand.

Du Vergleichsoperatoren sollten als Member const sein.

Über das "kick-delete-createnew-zyklus mit macro-art remebering" würde ich natürlich auch noch gerne aufgeklärt werden.

das heißt nur, daß ich vorschlage, den kram wegzuwerfen, zu löschen, neu zu schreiben und dabei sich an die kunst der makro-programmierung zu erinnern. könnte sein, daß es dann fast genausogut wird aber deutlich einfacher.