"Prankster Kineses" <spam.me.senseless@spam.spam> wrote in message
news:bh0v03$pmt$1@sunsite.dk...
[8<8<8<]
> > Er du sikker på at du har et problem, der trænger til at blive løst ?
> >
> Nej egentlig ikke.
Det er nok det mest almindelige.
> Jeg har for vane altid at bruge helt almindelig
> returnering uden reference eller noget,
Det er et fornuftigt udgangspunkt - for typer med value semantik som f.eks.
dato-objekter.
> men så påpegede een for mig, at for
> meget store objekter og ved hyppige kald bør man returnere en reference
> eller pointer for at undgå kopiering.
Det er ikke helt forkert men heller ikke helt rigtigt.
Men check at der er et problem, inden du begynder at optimere.
>
> > Har du undersøgt om der rent faktisk bliver lavet en kopi ?
>
> Nej, hvordan ser jeg det?
Du kan f.eks. lave en copy-constructor og se om den bliver kaldt - f.eks.
med en debugger.
[8<8<8<]
> Gælder det ikke kun for "primitives" som int, double, etc og klasser som
> indeholder primitives?
Nej, bestemt ikke.
Det gælder alle klasser, men compileren har lov til at lade være med at
optimere det ekstra objekt væk.
Forskellige compilere har forskellige kriterier for hvornår de optimerer det
væk.
F.eks. giver:
<C++ kode>
#include <iostream>
#include <string>
class foo
{
public:
foo(const char* text_arg);
foo(const foo& source_arg);
~foo();
private:
std::string text;
};
foo::foo(const char* text_arg) :
text(text_arg)
{
std::cout << "constructor foo::foo called" << std::endl;
}
foo::foo(const foo& source_arg) :
text(source_arg.text)
{
std::cout << "copy constructor foo::foo called" << std::endl;
}
foo:
foo()
{
std::cout << "destructor foo:
foo called" << std::endl;
}
foo get_foo(const char* text_arg)
{
foo result(text_arg);
return result;
}
int main()
{
foo f = get_foo("bar");
}
</C++ kode>
følgende
<output>
constructor foo::foo called
destructor foo:
foo called
</output>
når det oversættes med Intel C++ V7.0 med optimering slået til
[8<8<8<]
> > Har du undersøgt i hvilken udstrækning den ekstra kopi udgør et problem.
> > Igen skal du måle på optimeret kode.
> >
> Jeg er ikke sikker på det er et decideret problem, jeg ville bare være
på
> den sikre side og gøre det ordentligt.
Men hvad er ordentligt ?
Alt andet lige er det bedst at have funktioner, der er nemme og sikre at
bruge.
Hvis det viser sig at der er et performance problem, så gør enten klassen
billigere at kopiere eller lad funktionen returnere et std::auto_ptr objekt.
Det er ofte unødvendigt farligt at have en funktion, der allokerer noget og
det kun står i dokumentationen at man skal huske at frigive det.
Venlig hilsen
Mogens Hansen