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

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

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?

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

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....

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.

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...

Schau dir nochmal meinen Post an.

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!!!!