std::string nachprogrammieren?

Hallo!

Ich fange jetzt an, mich in Sachen STL etwas fortzubilden und da hätt ich gleich mal eine Frage:

Kann ich mit C++ Bordmitteln z.B. die Verkettungsmöglichkeit "abc" + i + "uiui" von std::string nachprogrammieren?
Da die STL einfach eine Sammlung von Template Klassen ist, sollte das ja möglich sein...

Wenn ja, welche Operatoren muss ich z.B. für so eine Verkettung überladen? Warum hat z.B. der MFC CString sowas nicht implementiert?

Klar kannst du CStrings verketten:

CString str= "Hallo";
str += _T(" Welt!");

MfG

Shlo

cppFan schrieb:

Wenn ja, welche Operatoren muss ich z.B. für so eine Verkettung überladen?

?? operator!= oder operator[] vielleicht?

Meine Güte, denk mal logisch nach: wenn du etwas in der Form a + b + c verketten möchtest, welchen operator würdest dann überladen? Richtig! operator+ !

Und jetzt versuch du mal...

prolog

Hallo,

Welche Operatoren du überladen musst weisst du ja nun. Als übung sowas wie std::string nachprogrammmieren ok, aber als Ersatz würde ich es nicht probieren. Das Heapmanagement der STL kann man kaum besser machen.

Jaja ok, das ist mir eh klar. Und dass man beim CString mit += was dranhängen kann weiß ich auch. Allerdings geht das eben nur 1x, 'CString x = "a" + "b"' schlägt z.B. mit der Fehlermeldung "Zwei Zeiger koennen nicht addiert werden" fehl.

Aber um die CStrings gehts mir ja gar nicht, was ich nicht checke ist, wie man eben mehrere "a" + i + "c" Verkettungen mit dem operator+ hinkriegt, da op+ ja irgendwie so gemacht wird: str operator+(const str &, const str &) => Da gibts 2 Parameter, wie kann ich damit so eine Kette auflösen?!
.... ähm.. moment: vielleicht indem die kette von links nach rechts abgearbeitet wird und operator+ dann beim obigen bsp. halt 3x aufgerufen wird..?

prolog

Hallo,

das lässt sich lösen in dem nu beim Operator eine Referenz auf das Object zurück gibst.

const MyClass &MyClass::operator+(const MyClass &c){
   //addition
   return *this;
}

ahh ok danke

Shlo

operator+ sollte normalerweise keine Referenz zurückgeben, sondern eine Kopie!

struct A { A(int = 0) { } A operator+(const A&) const { return A(); } };

const A a1, a2;
A a3 = a2 + 3 + a1 + 4 + 6;

//a2.operator+(3).operator+(a1).operator+(4).operator+(6);

//oder

struct A { A(int = 0) { } };
A operator+(const A&, const A&) { return A(); }

const A a1;
A a2 = 3 + a1 + 5;

//A(3).operator+(a1).operator+(5); //usw.

Shade Of Mine

cppfan schrieb:

"Zwei Zeiger koennen nicht addiert werden"

Ja, weil du Zeiger nicht addieren kannst. und "a" und "b" sind Zeiger und keine Objekte.

Grundlagen lernen, bitte.

Jester

prolog schrieb:

Hallo,

das lässt sich lösen in dem nu beim Operator eine Referenz auf das Object zurück gibst.
const MyClass &MyClass::operator+(const MyClass &c){
   //addition
   return *this;
}

op+ doch bitte nicht als Member!

Was erwartest Du Dir denn von

MyIntClass a = 4;
a+1;
cout << a;

Doch wohl nicht 5, oder?

Shlo

Jester schrieb:

op+ doch bitte nicht als Member!

Warum nicht? Nehmen wir an der ctor ist explicit...

Jester

Hast Du das Beispiel gelesen?

Shlo

Ja, und weiter? Was macht jetzt dein operator+?

Jester

Dann versteh's doch bitte noch.
So wie prolog das beschrieben hatte wird bei

a+5;

a verändert. Und das ist vollkommen unerwartet. Also wenn schon, dann ein neues Objekt zurückgeben, keine Referenz. Das bitte nur beim op= oder den op+= und Konsorten.

So, warum jetzt kein Member?
Weil dann auf dem linken Parameter keine Konvertierung durchgeführt werden kann.

Warum sollte denn

"Hallo"+5; erlaubt sein, aber 5+"Hallo" nicht?

MfG Jester

Shlo

Irgendwie erzählst du mir nicht Neues, denn das wurde von mir bereits oben gepostet...

Warum sollte denn

"Hallo"+5; erlaubt sein, aber 5+"Hallo" nicht?

macht keinen Sinn, warum sollte ich einen String-Literal mit einem int addieren? Zudem muss beim Überladen von Operatoren, einer der Parameter von Class-Type sein.

SideWinder

Es ist so, wenns dich interessiert warum ließ ecp kapitel 23...

class myclass
{
    friend myclass operator + (const myclass& lhs, const myclass& rhs);
};

myclass operator + (const myclass& lhs, const myclass& rhs)
{
    myclass ret;
    // ret = lhs + rhs
    return(ret);
}

So schauts aus.

MfG SideWinder

Shlo

SideWinder schrieb:

So schauts aus.

Du auch nicht...

prolog

Hallo,

@alle Nachposter
Sry habs mit dem Zuweisungsoperator verwechselt.

SideWinder

Shlo schrieb:

SideWinder schrieb:

So schauts aus.

Du auch nicht...

Warum er kein Member sein soll ist doch irgendwo klar. Nehmen wir an ein CTor ist nicht explicit (ist ja sehr oft der Fall), dann gibts plötzlich Probleme die mit einem globalen op nicht passieren.

MfG SideWinder

Jester

gelöscht