OOP für duµs

Walli

Sicher, dass das genau so da steht?

Shade Of Mine

MaSTaH schrieb:

Sicher, dass das genau so da steht?

jep, leider.

Heuschrecke

*stolzsei*

terraner

Shade Of Mine schrieb:

const OpDemo1& operator+(const OpDemo1& right)
{
   m_Value+=right.getValue();
   return *this;
}

wieso eine referenz auf das bestehende objekt übernehmen? und wieso eine referenz auf rhs/right?

String String::operator+ (const String rhs) 
{
    String tmp;
    tmp = String(*this);
    tmp += rhs;

 return tmp;
}

schließlich ist es ja normalerweise das "ziel" mit einem '+', zwei werte zu addieren und einem dritten objekt zu speichern.

ps: "-W -Wall -ansi -pedantic", Dev-Cpp 49.87

[edit]das ist meine string class[/edit]

mfg

rüdiger

@terraner

man benutzt const-Referenzen idr. zum übergeben von nicht-Builtin Typen, weil man sich den Aufruf des copy-ctors spart, was deutlich schneller sein sollte

terraner

kingruedi schrieb:

@terraner

man benutzt const-Referenzen idr. zum übergeben von nicht-Builtin Typen, weil man sich den Aufruf des copy-ctors spart, was deutlich schneller sein sollte

O_o, stimmt ja, dann wird der CpyCtor gar nicht aufgerufen, wenn ich eine referenz übergebe. ach was, ihr habt bloß noch niemeine extrem schnellen cpyctors gesehen. dann würdet ihr anders urteilen
Danke für den Hinweis!

mfg

String tmp;
    tmp = String(*this);

und sowas auch direkt machen

String tmp(*this);

davie

wenn wir schon dabei sind, eigentlich ist es ja

String operator + (const String &a, const String &b) {
   String tmp(a);
   tmp += b;
   return tmp;
}

terraner

davie schrieb:

wenn wir schon dabei sind, eigentlich ist es ja
String operator + (const String &a, const String &b) {
   String tmp(a);
   tmp += b;
   return tmp;
}

das funzt bei mir nicht. das habe ich auch so in meinem tut gelesen (c++ in 21 tagen), aber dev-cpp meckert dann rum, dass "operator+ must take either zero or one argument". deshalb mache ich das so.

mfg

davie

->definiere operator+ nicht als memberfunktion.

class String {
/* ... */
};

String operator + (/* ...
*/

terraner

davie schrieb:

->definiere operator+ nicht als memberfunktion.
class String {
/* ... */
};

String operator + (/* ...
*/

noch etwas gelernt. danke.
ich habe es inzwischen aber so gemacht:

String String::operator+ (const String &rhs) 
{
    String tmp(this->m_pChar);
    tmp += rhs;

 return tmp;
}

ist das genauso schnell?

mfg

davie

wenn das

String tmp(this->m_pChar);

nicht schneller als ein copy ctor ist.

allerdings liegen bei + als member funktion ganz andere probleme.
stell dir vor

String foo("blub");

String bar = foo + "ok";
String nope = "oje" + foo; //crash

weil der compiler versucht, "oje" + foo; aufzulösen in

"oje".operator+ (foo); //das klappt nicht
//andersrum
foo.operator+ ("oje"); //klappt allerdings schon, wenn es eine konvertierung von const char* nach String gibt.

der zweiparametrige operator+ kann jedoch auch sein erstes argument notfalls umwandeln.