<< Operator überladen

[aendue]

Guten Morgen liebe Gemeinde,
ich würde gerne den << Operator in einer Klasse überladen, so dass ich den Operator mehrfach in einer Zeile verwenden kann. Die Operatoren sind immer Objekte der Klasse.
Die Aufgabenstellung:

Aufgabe:
Die Klasse firma aus Aufgabe 1 soll nun so erweitert werden, dass sich zwei Firmen nicht nur mit Hilfe des Operators + zusammenschliessen können, sondern dass eine Firma mehrere andere Firmen übernehmen kann. Überladen Sie hierzu den Operator << derart, dass Sie die Übernahme mehrerer Firmen in einer einzigen Code-Zeile angeben können. Übernommene Firmen sollen innerhalb der Klasse firma in einem Array mit zehn Feldern vom Typ std::string gespeichert werden.

TIPP für die Aufgabenstellung:
Sie müssen nun den Operator << für die Klasse firma überladen. Nachdem eine Firma eine andere Firma übernehmen soll und somit beide Operanden wieder Objekte vom Typ firma sind, können Sie auch in diesem Fall den Operator als Methode überladen. Hierbei ist nun wichtig, dass der überladene Operator als Rückgabewert den jeweils ersten Operanden als Referenz liefert - andernfalls ist es nicht möglich, innerhalb einer Zeile mehrere Objekte vom Typ firma mit << zu verknüpfen.

Ich komme leider nicht weiter, weil ich mir nicht sicher bin, wie ich den ersten Operanten zurückgeben kann.

Meine Lösung

firma.h

#pragma once
#include <string>
#include <iostream>

class firma
{
public:
	firma(std::string name);
	~firma(void);
	void operator+(firma &f);
	firma operator<<(firma &f);
	void name(); 
	void show();
private:
	std::string Name;
	std::string Firmen[10]; 

};

firma.cpp

#include <iostream>
#include "firma.h"

firma::firma(std::string name) : Name(name)
{
}

firma::~firma(void)
{
}

void firma::operator+(firma &f)
{
	Name += "&" + f.Name;
	f.Name = Name;
}

firma firma::operator<<(firma &f)
{
	int i;
	for(i=0;i<10;i++)
	{
		if(Firmen[i] == "")
		{
			Firmen[i]=f.Name;
			break;
		}
	}
	return firma;  
}

void firma::name()
{
	std::cout << Name << std::endl;
}
void firma::show()
{
	int i;
	for(i=0;i<10;i++)
	{
		std::cout << Firmen[i] << std::endl;
	}
}

In der main würde ich dann gerne 3 Objekte erstellen und mit a<<b<<c; die einzelnen Firmen zusammenbringen.

Ih hoffe Ihr könnt mir helfen.

MFG
aendue

[Braunstein]

Hallo,

Lies doch einfach mal den Artikel zu Operatorüberladung im Magazin, Abschnitt 3.4
http://www.c-plusplus.net/forum/232010

[aendue]

Ja hab ich auch schon gefunden, hat mich aber bis jetzt nicht weitergebracht.

Da steht auch nicht die Implementierung in einer Klasse.

Da steht:
"Da der linke Operand das Streamobjekt ist und die Klassen der Standardbibliothek nicht nachträglich erweitert werden können, müssen die Streaming-Operatoren als freie Funktionen definiert werden.
Übliche Implementierung: "

Aber das stht doch im wiederspruch zum den Tipp:

"Nachdem eine Firma eine andere Firma übernehmen soll und somit beide Operanden wieder Objekte vom Typ firma sind, können Sie auch in diesem Fall den Operator als Methode überladen."

Das ist grad das was mich verwirrt...Geht das nur als freie Funktion, oder kann ich das auch in der Klasse implementieren?

[sone_logoff]

return firma;

Du musst dich nochmal mit den Grundlagen in C++ auseinandersetzen. firma ist eine Klasse, Funktionen können nur Objekte und Referenzen zurückgeben.

[Braunstein]

Warum willst du den Operator in der Klasse haben? Der Operator sollte nie Member der Klasse sein. Wenn du ihn unbedingt in der Klasse implementieren willst mach ihn zum friend.
siehe auch
http://stackoverflow.com/questions/476272/how-to-properly-overload-the-operator-for-an-ostream

[aendue]

Im Tipp steh ja:
"dass der überladene Operator als Rückgabewert den jeweils ersten Operanden als Referenz liefert"

Und das ist ja auch die Stelle, wo ich nicht weiter komm....Wie geb ich den ersten Operanten zurück?

return &firma ist es auch nicht....

[Braunstein]

Der erste Operand ist der Stream. Den gibst du als Referenz zurück.

[Nathan_logoff]

aendue schrieb:

Im Tipp steh ja:
"dass der überladene Operator als Rückgabewert den jeweils ersten Operanden als Referenz liefert"

Und das ist ja auch die Stelle, wo ich nicht weiter komm....Wie geb ich den ersten Operanten zurück?

return &firma ist es auch nicht....

Was ist denn der erste Operand?
Schreibst du:

firma a, b;
a << b;

Ist das in deinem Fall das gleiche wie:

firma a, b;
a.operator<<(b);

Der erste Operand ist a - also das aktuelle Objekt.
Und wie kommt man an das erste Objekt? Richtig mit this.
Du schreibst also:

firma& operator << (firma &f) // muss via Referenz zurückgegebenwerden, weil sonst bei Verkettung nicht richtig funktioniert
{
    ...
    return *this;
}

@Braunstein:
Es geht hier nicht um den Outputoperator.

[aendue]

Meine neue Lösung:

firma.h

#pragma once
#include <string>
#include <iostream>

class firma
{
public:
	firma(std::string name);
	~firma(void);
	void operator+(firma &f);
	friend std::ostream& operator<<(std::ostream& op, firma& f);
	void name(); 
	void show();
private:
	std::string Name;
	std::string Firmen[10]; 

};

firma.cpp

#include <iostream>
#include "firma.h"

firma::firma(std::string name) : Name(name)
{
}

firma::~firma(void)
{
}

void firma::operator+(firma &f)
{
	Name += "&" + f.Name;
	f.Name = Name;
}

std::ostream& operator<<(std::ostream& op, firma& f)
{
	???

	return op;
}

void firma::name()
{
	std::cout << Name << std::endl;
}
void firma::show()
{
	int i;
	for(i=0;i<10;i++)
	{
		std::cout << Firmen[i] << std::endl;
	}
}

Ich hab das jetzt mal so implementiert, aber jetzt kann ich mir grad schlecht vorstellen, was in dem ostream "drin streckt".
Also ich weiß jetzt ehrlich nicht genau, wie ich jetzt das Array füllen kann.

Wenn ich jetzt in der main funktion a<<b<<c; eingebe, dann merkert er, weil der Operator nicht mit den Operaten überin stimmt.

Ich verzweifle noch...

[Nathan_logoff]

Das was du jetzt gemacht hast, ist der Output Operator, mit dem du Sachen auf cout ausgeben kannst. Den brauchst du in diesem Fall nicht.

Schau dir nochmal meinen Post an.

[aendue]

@Nathan_logoff
Danke für deine Hilfe, das hat mich zum Ziel gebracht. Es wird quasi nicht der output operator überladen, sondern der << Operator der Klasse Firma...Kann man das so sagen?

Jetzt fünktioniert es!!!

Lösung:

firma.h

#pragma once
#include <string>
#include <iostream>

class firma
{
public:
	firma(std::string name);
	~firma(void);
	void operator+(firma &f);
	firma& operator<<(firma &f);
	void name(); 
	void show();
private:
	std::string Name;
	std::string Firmen[10]; 

};

firma.cpp

#include <iostream>
#include "firma.h"

firma::firma(std::string name) : Name(name)
{
}

firma::~firma(void)
{
}

void firma::operator+(firma &f)
{
	Name += "&" + f.Name;
	f.Name = Name;
}

firma& firma::operator<<(firma &f)
{
	int i;
	for(i=0;i<10;i++)
	{
		if(Firmen[i] == "")
		{
		Firmen[i]=f.Name;
		break;
		}
	}
	return *this;
}

void firma::name()
{
	std::cout << Name << std::endl;
}
void firma::show()
{
	int i;
	for(i=0;i<10;i++)
	{
		std::cout << Firmen[i] << std::endl;
	}
}

#include <iostream>
#include "firma.h"

void main()
{
	firma d("Dell");
	firma i("IBM");
	firma g("golem");
	firma n("net");

	d<<i<<g<<n;

	d.show();

}

Vielen Dank nochmals!!!!