operator +

Imam en custom string class CMyStr in na njem deklariran operator +:

friend CMyStr operator+(const CMyStr& first, const char* other);

Ideja je v tem, da bi naj dva stringa zlepil skupaj. Zadeva špila na MSVC in gcc 3.x, sedaj pa poskušam zadevo prevesti na gcc 4.

Koda:

CMyStr str;
str = "abc";
str = str + "efg";

Javi napako :

./AdmUporabniki.cpp:728: error: no matching function for call to CMyStr::CMyStr(CMyStr)
../MyLib/MyStr.h:176: note: candidates are: CMyStr::CMyStr(const char*)
../MyLib/MyStr.h:175: note: CMyStr::CMyStr(unsigned int)
../MyLib/MyStr.h:71: note: CMyStr::CMyStr(CMyStr&)


Če kličem samo kot:

str + "efg";

ali

str = (str + "efg").c_str() // .c_str() vrne const char *;

pa deluje. Kaj storiti?

CMyStr();
CMyStr(unsigned int chunksize);
CMyStr(const char * string);

Na sploh mi ni jasno zakaj se sploh kliče konstruktor. V funkciji CMyStr operator +(CMyStr &first, const char* other), se alocira ena spremenljivka tipa CMyStr, ki se potem kot rezultat vrne na stack.

Sedaj sem malo popravil, tako, da imam eno globalno spremenljivko, ki jo v funkciji napolnem, potem pa trnem referenco;


CMyStr CMYSTR_RETURN_VAL;
CMyStr &operator+(const CMyStr& first, const char* other){
CMYSTR_RETURN_VAL.Clear();
CMYSTR_RETURN_VAL += first;
CMYSTR_RETURN_VAL += other;
return CMYSTR_RETURN_VAL;
}

S tem sem sicer izgubil thread safty samo vsaj str = str + "abc" dela. Bol kompleksni primer kot:

str = str + "[" + str2 + "]";

Pa še vedno javi enako napako.

> str = str + "efg";

Bi rekel da se iz navedenega lahko zgodi tole:

operator + (...) {
   CMyStr Ret;
    str + "efg" nastima Ret
    return Ret;
}

return Ret se potem prevede v:
CMyStr Tmp(ret);

in potem se na koncu:

str = Tmp;

Lahko se pa zgodi tudi tole (g++ 3.2/3.3/3.4 precej zagreto optimizirajo konstruktorje):

operator + (...) {
   CMyStr Ret;
   str + "efg" nastima Ret
   return Ret;
}

return Ret se pa potem prevede kar v:
str = Ret;

Torej, odvisno je kako compiler optimizira in to lahko odkrije kako dodatno napako v tvoji kodi.

MAsterBlaster, če še spremljaš temo, ti dam še en nasvet. Kontruktor
CMyStr(unsigned int chunksize);
spremeni v
explicit CMyStr(unsigned int chunksize);
da se ti ne bo še kaj čudnega dogajalo (recimo avtomatska pretvorba iz unsigned int v CMyStr).

Sem te hotel napotiti na nadalnje branje a pravzaprav imam čas da ti vsaj malo razložim tole. Konstruktorji se včasih uporabljajo tudi za pretvorbo tipov. Recimo v tvojem primeru lahko poskusiš tole (še preden dodaš tisti explicit):
dodaš funkcijo (lahko tudi kaj naredi ta funkcija, če želiš preveriti ali se res izvede)
funkcija (CMyStr str) {}
in potem kličeš funkcijo takole:
funkcija("ahaha!");
funkcija(10);
Prevajalnik bo oboje požrl, ker bo za oba primera našel konstruktorja z enim parametrom (unsigned int oz. const char*.) s pomočjo katerega lahko ta parameter pretvori v CMyStr in ga nato podtakne funkciji. V prvem primeru je to celo zaželjeno v drugem pa verjetno ne. Zato uporabiš explicit, kar pomeni, da se konstruktor ne sme uporabljati za pretvorbo ampak se sme uporabiti explicitno le za konstrukcijo, se pravi, ko ga sam direktno kličeš.

Pa še ena malenkost:
CMyStr &operator+(const CMyStr& first, const char* other);
to je nadvse slabo.
CMyStr operator+(const CMyStr& first, const char* other);
tako se pa to dela. Če seštevaš dve vrednosti se razume da boš dobil neko novo vrednost. Optimizacija s referencami tu ne pride v poštev (niti ni ne vem kako uspešna optimizacija tole). Poleg tega ima pa še eno hudo napako:
CMyStr a("a"), b("b"), c("c"), d("d");
a = b + c + d;
Ugani vrednost a

Če že nujno hočeš sam spisati String class potem si vsaj poglej katere funkcije in konstruktorji so implementirani pri std::string, ker sam boš zelo težko kaj boljšega iznašel.