🚀 go-pugleaf

Bernhard Dobbels wrote:
> 
> Kurt Lefevre <kurt.lefevre@capitalmarketscompany.com> wrote:
> >Geen van beiden:
> >In object moet const zijn. Dit vermijdt dat je ongewild het object kan
> >wijzigen in de method.
> >Verder is de gebruikelijke manier een ref naar het out object als return
> >value.
> 
> en zojuist heb ik geleerd dat dit geen 'propere' methode is.
> Als je een ref naar een object teruggeeft, dan heb je dat object aangemaakt
> in de functie. Het object moet later gedeleted worden, en dat zal dan op een
> ander niveau in je programma moeten zijn (niet in die functie) en dat mag niet,
> want op het einde van de functie wordt de destructor automatisch aangeroepen.
 
> De goede methode is dus altijd uw object aan te maken in de oproepende functie
> en een 'object& const objectname': een constante referentie naar een variabel
> object.

ofwel:
  const object funktie(const object& object_in);
ofwel:
  void funktie(const object& object_in, object& object_out);
ofwel:
  object *funktie(const object& object_in);
ofwel:
  object& method(const object& object_in);

waarom?

- het eerste gebruik je als 'object' klein is en/of het extra copieren
  geen kwaad kan (bvb. wanneer snelheid niet over-belangrijk is), en
  object heeft een copy-constructor.
- het tweede gebruik je in de andere gevallen
- het derde gebruik je als de funktie een 'maker' is van dingen
  (op de heap), en met de pointer duid je aan dat de gebruiker
  verantwoordelijk wordt voor destructie (via afspraak).
- het vierde gebruik je als de funktie een referentie teruggeeft
  naar bestaande data (bvb. ergens opgezocht), die je niet wil
  copieren (omdat het dan zijn zin verliest bvb de gebruiker wil erin
  kunnen wijzigen of omdat het een groot object is en snelheid is
  belangrijk (maar dan zou het eerder een const object& zijn dat
  ge-returned wordt)). het 4de is gebruikelijker bij methods
  waar er impliciet lokale data aanwezig is.

(dit zijn maar vuistregels die ik gebruik, YMMV).

koen.