ich habe ein kleines Problemchen, und zwar habe ich in meinem Programm eine Klasse Display, über die alle Textausgaben auf dem Bildschirm ausgegeben werden sollen.

Soweit so gut, die Methode sieht folgendermaßen aus:

void Display::stringOutput(string aString)
{
    cout << aString << endl;
}

Bloß wenn ich jetzt etwas in der Art hier ausgeben will:

stringOutput ("lalala" + aString);

Hab ich die Methode überladen:

void Display::stringOutput(string firstString, string secondString)
{
    cout << firstString + secondString << endl;
}

Was aber, wenn ich etwas in der Manier ausgeben möchte:

stringOutput("Blabla" + aString + "lalal");

Dann müsste ich die Methode ja wieder überladen?

Das kann man doch bestimmt auch eleganter lösen oder ?
Ich möchte nicht für jeden Parameter der dazu kommt, die Methode überladen müssen

Könnt ihr mir da vll. weiterhelfen ?

Ansonsten: Nun rate mal, warum das bei den Streams mit Operatoren gemacht wurde, die man so schön hintereinander schalten kann.

Ansonsten: Nun rate mal, warum das bei den Streams mit Operatoren gemacht wurde, die man so schön hintereinander schalten kann.

Was nicht unbedingt eine Eigenschaft von Operatoren ist, bei denen sieht es einfach nur schöner aus.

class Display
{
public:
    Display(std::ostream& stream) : 
      stream_(stream)
    {}
    template<typename T>
    Display& Output(T t)
    {
        stream_ << t;
        return *this;
    }
private:
    std::ostream& stream_;
};

template<typename T>
Display& operator <<(Display& display, T t)
{
    display.Output(t);
    return display;
}

int main()
{
    Display display(std::cout);
    display.Output("hallo").Output(1).Output("Welt");
    display  << 123 <<  "hello world\n";
}