[lnkForumImage]
TotalShareware - Download Free Software

Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.c++

initialisation list in constructor

Taras_96

10/23/2008 11:26:00 PM

Hi everyone,

The FAQ at http://www.parashift.com/c++-faq-lite/ctors.htm...
states that:

"Consider the following constructor that initializes member object x_
using an initialization list: Fred::Fred() : x_(whatever) { }. The
most common benefit of doing this is improved performance. For
example, if the expression whatever is the same type as member
variable x_, the result of the whatever expression is constructed
directly inside x_ — the compiler does not make a separate copy of the
object. Even if the types are not the same, the compiler is usually
able to do a better job with initialization lists than with
assignments.

The other (inefficient) way to build constructors is via assignment,
such as: Fred::Fred() { x_ = whatever; }. In this case the expression
whatever causes a separate, temporary object to be created, and this
temporary object is passed into the x_ object's assignment operator.
Then that temporary object is destructed at the ;. That's inefficient.

As if that wasn't bad enough, there's another source of inefficiency
when using assignment in a constructor: the member object will get
fully constructed by its default constructor, and this might, for
example, allocate some default amount of memory or open some default
file. All this work could be for naught if the whatever expression and/
or assignment operator causes the object to close that file and/or
release that memory (e.g., if the default constructor didn't allocate
a large enough pool of memory or if it opened the wrong file). "

I believe that if you write Fred::Fred() {x_ = whatever;} then
effectively what you're getting is Fred::Fred(): x_(whatever) {x_ =
whatever;}. This is what I think the last paragraph is saying (the
member object will get fully constructed by it's default constructor).

However, I don't see what the second paragraph is saying. If whatever
is a primitive, then no 'temporary object' will be created. If
whatever is an object, then a temporary object would have to be
created anyway in the initialisation example anyway:

Fred::Fred(): x_(WhateverClass()) {}

When is the temporary copy being referred to created?

in a 'normal function':

if we write:

Foo foo = bar;

then whether a temporary Bar object is created depends on the
definition of the Foo constructor:

Foo(Bar &); // no copy made
Foo(Bar); // copy made

Taras
8 Answers

Salt_Peter

10/24/2008 12:36:00 AM

0

On Oct 23, 7:25 pm, Taras_96 <taras...@gmail.com> wrote:
> Hi everyone,
>
> The FAQ athttp://www.parashift.com/c++-faq-lite/ctors.htm...
> states that:
>
> "Consider the following constructor that initializes member object x_
> using an initialization list: Fred::Fred() : x_(whatever) { }. The
> most common benefit of doing this is improved performance. For
> example, if the expression whatever is the same type as member
> variable x_, the result of the whatever expression is constructed
> directly inside x_ — the compiler does not make a separate copy of the
> object. Even if the types are not the same, the compiler is usually
> able to do a better job with initialization lists than with
> assignments.
>
> The other (inefficient) way to build constructors is via assignment,
> such as: Fred::Fred() { x_ = whatever; }. In this case the expression
> whatever causes a separate, temporary object to be created, and this
> temporary object is passed into the x_ object's assignment operator.
> Then that temporary object is destructed at the ;. That's inefficient.
>
> As if that wasn't bad enough, there's another source of inefficiency
> when using assignment in a constructor: the member object will get
> fully constructed by its default constructor, and this might, for
> example, allocate some default amount of memory or open some default
> file. All this work could be for naught if the whatever expression and/
> or assignment operator causes the object to close that file and/or
> release that memory (e.g., if the default constructor didn't allocate
> a large enough pool of memory or if it opened the wrong file). "
>
> I believe that if you write Fred::Fred() {x_ = whatever;} then
> effectively what you're getting is Fred::Fred(): x_(whatever) {x_ =
> whatever;}. This is what I think the last paragraph is saying (the
> member object will get fully constructed by it's default constructor).
>
> However, I don't see what the second paragraph is saying. If whatever
> is a primitive, then no 'temporary object' will be created. If
> whatever is an object, then a temporary object would have to be
> created anyway in the initialisation example anyway:
>
> Fred::Fred(): x_(WhateverClass()) {}
>
> When is the temporary copy being referred to created?

If you assign x_ in the ctor body instead of the init list, Fred's
ctor needs to allocate its members at the very least. This happens
before the ctor's body is processed.

....in the same breath ...
int temp(0);
int m = temp; // is a copy

note the difference now:
int temp(0);
int m;
m = temp; // is not a copy. assignment

The difference is that the first set of statements can be optimized
away, the assignment usually cannot.

>
> in a 'normal function':
>
> if we write:
>
> Foo foo = bar;
>
> then whether a temporary Bar object is created depends on the
> definition of the Foo constructor:
>
> Foo(Bar &); // no copy made
> Foo(Bar); // copy made
>
> Taras

Whether a temporary is created depends on whether its creation can be
optimized away or not.
In your second example, Foo(Bar); you'ld get 2 copies if it wasn't
optimized and you did use the init list (a temp is generated), 2
copies + op= if you didn't use the init list. In the first example
you'ld get a copy unless you were setting a member reference (no
temporary). Fortunately, that copy is usually optimized away.

For all intensive purposes, those paragraphs in faq-10.6 are relevent
since they give an overview of the difference between using the init
list and assignments. In reality the ctor, at the very least, will
allocate / reserve memory for its members before its body is
processed. Why not initialize those members using the init list then?

Copies are very fast usually. The same can't be said of allocation +
assignment.
Consider that most op= include an a self assignment check:

[http://www.parashift.com/c++-faq-lite/assignment-oper...]

Fred& Fred::operator= (const Fred& f)
{
if (this == &f) return *this; // Gracefully handle self
assignment

// Put the normal assignment duties here...

return *this;
}

There is no reason not to use the init list. For a programmer: its
often a blessing. Take for example a simple way to zap the unitialized
pointer issue:

class P
{
int* p;
public:
P() : p(0) { }
...
};

The init list is more than just about efficiency.

Victor Bazarov

10/24/2008 12:39:00 AM

0

Taras_96 wrote:
> [..]
> I believe that if you write Fred::Fred() {x_ = whatever;} then
> effectively what you're getting is Fred::Fred(): x_(whatever) {x_ =
> whatever;}. This is what I think the last paragraph is saying (the
> member object will get fully constructed by it's default constructor).

Actually, it's more like

Fred::Fred() : x_() { x_ = whatever; }

'x_' is default-initialised before being assigned to.

> However, I don't see what the second paragraph is saying. If [..]

You're basing your conclusions on a wrong premise, I'm afraid.

> in a 'normal function':
>
> if we write:
>
> Foo foo = bar;
>
> then whether a temporary Bar object is created depends on the
> definition of the Foo constructor:
>
> Foo(Bar &); // no copy made
> Foo(Bar); // copy made

No. By definition, the form

TypeA objA = objB;

is a shorthand for

TypeA objA((TypeA(objB)));

The syntax with the '=' is *not* direct initialisation, it is
copy-intialisation from a *temporary object*, which is in turn
directly initialised from 'objB'.

In reality the compiler most likely skips the temporary and makes
the code analogous to

TypeA objA(objB);

but the difference is that the copy constructor in 'TypeA' *must*
exist and be accessible. That's the requirement.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

blargg.h4g

10/24/2008 2:40:00 AM

0

In article <gdr5ep$gg0$1@news.datemas.de>, Victor Bazarov
<v.Abazarov@comAcast.net> wrote:

> Taras_96 wrote:
> > [..]
> > I believe that if you write Fred::Fred() {x_ = whatever;} then
> > effectively what you're getting is Fred::Fred(): x_(whatever) {x_ =
> > whatever;}. This is what I think the last paragraph is saying (the
> > member object will get fully constructed by it's default constructor).
>
> Actually, it's more like
>
> Fred::Fred() : x_() { x_ = whatever; }
>
> 'x_' is default-initialised before being assigned to.
[...]

....unless x_ is a built-in or POD type, in which case it has an
indeterminate value on entry to the constructor, before the assignment.

Ian Collins

10/24/2008 3:02:00 AM

0

blargg wrote:
> In article <gdr5ep$gg0$1@news.datemas.de>, Victor Bazarov
> <v.Abazarov@comAcast.net> wrote:
>
>> Taras_96 wrote:
>>> [..]
>>> I believe that if you write Fred::Fred() {x_ = whatever;} then
>>> effectively what you're getting is Fred::Fred(): x_(whatever) {x_ =
>>> whatever;}. This is what I think the last paragraph is saying (the
>>> member object will get fully constructed by it's default constructor).
>> Actually, it's more like
>>
>> Fred::Fred() : x_() { x_ = whatever; }
>>
>> 'x_' is default-initialised before being assigned to.
> [...]
>
> ....unless x_ is a built-in or POD type, in which case it has an
> indeterminate value on entry to the constructor, before the assignment.

No, x_() default initialises it.

--
Ian Collins

blargg.h4g

10/24/2008 5:03:00 AM

0

In article <6mcs5rFg531aU10@mid.individual.net>, Ian Collins
<ian-news@hotmail.com> wrote:

> blargg wrote:
> > In article <gdr5ep$gg0$1@news.datemas.de>, Victor Bazarov
> > <v.Abazarov@comAcast.net> wrote:
> >
> >> Taras_96 wrote:
> >>> [..]
> >>> I believe that if you write Fred::Fred() {x_ = whatever;} then
> >>> effectively what you're getting is Fred::Fred(): x_(whatever) {x_ =
> >>> whatever;}. This is what I think the last paragraph is saying (the
> >>> member object will get fully constructed by it's default constructor).
> >> Actually, it's more like
> >>
> >> Fred::Fred() : x_() { x_ = whatever; }
> >>
> >> 'x_' is default-initialised before being assigned to.
> > [...]
> >
> > ....unless x_ is a built-in or POD type, in which case it has an
> > indeterminate value on entry to the constructor, before the assignment.
>
> No, x_() default initialises it.

Sorry, I was referring to Taras_96's original example,

Fred::Fred() {x_ = whatever;}

noting that it is NOT exactly equivalent to Victor Bazarov's example,

Fred::Fred() : x_() { x_ = whatever; }

when x_ is a built-in or POD type. The difference would be hard to detect
in this case since x_ is immediately assigned a value.

James Kanze

10/24/2008 8:02:00 AM

0

On Oct 24, 1:25 am, Taras_96 <taras...@gmail.com> wrote:
> The FAQ
> athttp://www.parashift.com/c++-faq-lite/ctors.htm...
> states that:

> "Consider the following constructor that initializes member object x_
> using an initialization list: Fred::Fred() : x_(whatever) { }. The
> most common benefit of doing this is improved performance.

I'm going to disagree with the FAQ on this one. It's true that
doing so may result in improved performance, but that is rarely
the main motivation, or even a motivation. The most common
benefit of doing this is that it is cleaner; that you don't have
to worry about uninitialized or incorrectly initialized
variables in the body of your constructor. The general rule is
to never declare a variable without initializing it; member
variables are implicitlly declared before entering the
constructor, so logically, you want to initialize them before
entering the constructor.

Another frequent reason is that the type may not have a default
constructor (a lot of my types don't), so you have to initialize
it in the initializer list; otherwise, you get an error.

--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Taras_96

12/1/2008 1:43:00 PM

0

Thanks everyone for the excellent answers, it cleared up the confusion
around initialisation lists and temporaries :D. Back to Bjarne
Stroustrup's book....

Taras_96

12/1/2008 2:11:00 PM

0

On Oct 24, 12:38 am, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
> No.  By definition, the form
>
>      TypeA objA = objB;
>
> is a shorthand for
>
>      TypeA objA((TypeA(objB)));
>
> The syntax with the '=' is *not* direct initialisation, it is
> copy-intialisation from a *temporary object*, which is in turn
> directly initialised from 'objB'.
>
> In reality the compiler most likely skips the temporary and makes
> the code analogous to
>
>      TypeA objA(objB);
>
> but the difference is that the copy constructor in 'TypeA' *must*
> exist and be accessible.  That's the requirement.
>

So in the following passage: "The other (inefficient) way to build
constructors is via assignment, such as: Fred::Fred() { x_ =
whatever; }. In this case the expression whatever causes a separate,
temporary object to be created, and this temporary object is passed
into the x_ object's assignment operator. Then that temporary object
is destructed at the ;. That's inefficient. "

Does the author mean that:
x_ = whatever;
is equivalent to
x_.operator=(XConstructor(whatever));
?

So the first inefficiency mentioned is the right hand operand of the
assignment above. The second inefficiency mentioned is that the x_
will be default initialised, which may be wasteful. Is this correct?

I imagine that using an initialisation list would prevent both
inefficiencies, as x_ is no longer default initialised, nor is copy
assignment required (as x_ is initialised by 'whatever') .

Thanks again

Taras