Destruktor

Hallo,

kann mir einer sagen wie oft in folgendem Code der Destruktor aufgerufen wird und warum?

Dynamic f(Dynamic obj) 
{ 
      Dynamic localObj(100 + obj.getValue(), obj.getArraySize()); 
      return localObj; 
} 

int main() 
{ 
    Dynamic obj1(10,10), obj2; 
    obj2 = f(obj1); 
    cout << obj2.getValue() << endl; 

    char dummy; 
    cin >> dummy; 
    return 0; 
}

elise

Dynamic f(Dynamic obj)
{
      Dynamic localObj(100 + obj.getValue(), obj.getArraySize());
      return localObj;
}

ich lass das drinnen in dem verbund weg.

aber oben machst du zwei kopien... einmal bei der übegabe, einmal beim rückgabewert. also hier schon zweimal der destruktor.. und dann noch innen und in der main. zähl selber

billiger wäre es, per referenz zu arbeiten.

elise schrieb:

billiger wäre es, per referenz zu arbeiten.

meinst du günstiger?

prolog

billig == scheisse schrieb:

elise schrieb:

billiger wäre es, per referenz zu arbeiten.

meinst du günstiger?

Ja und nein, wenn du dich hier mal umschaust wirst du in posts öfter sowas lesen wie:

der und der aufruf der methode ist teuer.

oder

man muss dann keine teure kopie machen

Naja und billig iz nu mal das gegenteil. Deswegen vermutlich,

Also nicht billiger im sinne von schlechter.

camper

Dynamic f(Dynamic obj) 
{ 
      Dynamic localObj(100 + obj.getValue(), obj.getArraySize()); 
      return localObj;
}  // 0(NRVO) oder 1 mal(kein NRVO)

int main() 
{ 
    Dynamic obj1(10,10), obj2; 
    obj2 = f(obj1);     // 2 mal (ergebnis und argument) von f
    cout << obj2.getValue() << endl; 

    char dummy; 
    cin >> dummy; 
    return 0; 
} // 2 mal (obj2 dann obj1)

RHBaum

Dynamic f(Dynamic obj)
{
Dynamic localObj(100 + obj.getValue(), obj.getArraySize());
return localObj;
} // 0(NRVO) oder 1 mal(kein NRVO)

gcc solltes es so mit nrvo packen ...
glaub aber der MSVC 6.0 kanns nicht ... bin mir aber nicht sicher, muss es noch mal testen ...

bei

Dynamic f(Dynamic obj) 
{ 
      return Dynamic(100 + obj.getValue(), obj.getArraySize()); 
}

packt ers aber definitiv auch ....

aelteren compilern muss man halt auf die spruenge helfen

teuer in dem Kontext = inneffizent bei der ausfuehrung zur laufzeit
man liest immer "new" aufrufe sind teuer - gemeint "new" aufrufe kosten dich ne Menge rechenzeit, deshalb vielleicht das teuer

@GR_Watto
Wie schon angedeutet, iss mindestens 1 deiner kopien, und damit auch 1 mal destruktor uberfluessig
Wenn man sich schon von beginn die nutzung von const angewoehnt, kann man viel aussagkraeftigren, schoeneren und teilweisse effizeinteren code schreiben ...

Dynamic f(const Dynamic & robj) 
{ 
      return Dynamic(100 + robj.getValue(), robj.getArraySize()); 
}

Waer so ziemlich die effektivste Version deiner Funktion, vorrausgesetzt natuerlich, dass deine funktionen an Dynamic (getValue & getArraySize) const richtig deklariert sind.
Wobei das const Dir eigentlich keine zusaetzliche Optimierung bringt, sondern einfach nur ne weitere zusicherung ist, und die Funktion selber universeller macht (weil eben auch const objecte mit gehen )

Ciao ...