initializer Vs assignment list in constructor

[Pallav singh]

How can we justify that initializer list is better in performance
than assignment list in constructor of C++ ??

 

[Jack Klein]

How can we justify that initializer list is better in performance
than assignment list in constructor of C++ ??

Why would we want to justify it? The C++ standard does not specify or
require such a thing.

An initializer list is the preferred way to initialize the members in
a constructor. It is the only possible way to initialize reference
members and constant members. So just use initializer lists.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

 

[James Kanze]

On Tue, 15 Jan 2008 22:51:15 -0800 (PST), Pallav singh

Why would we want to justify it? The C++ standard does not
specify or require such a thing.

An initializer list is the preferred way to initialize the
members in a constructor. It is the only possible way to
initialize reference members and constant members. So just
use initializer lists.

You might add that by using an initializer list, you reduce the
chances of accidentally using the variable before it has been
initialized. It's part of the larger philosophy of never
defining a variable without initializing it.

 

[Erik Wikström]

Why would we want to justify it? The C++ standard does not specify or
require such a thing.

No it does not, but it does guarantee some other things that makes it
very probably that using the initialiser-list if slightly more
efficient. Consider a class like this:

class Foo
{
Bar bar;
Baz baz;

public:
Foo(int a,int b);
}

And assume that both Bar and Baz each have constructors taking an
integer, a default constructor, and a assignment operator.

Before the body of the constructor starts to execute all members of the
class have to be initialised (so that they are complete objects when the
body of the constructor executes). If you want bar and baz to be objects
created with a and b passed to their constructors and do not use an
initialisation-list you would have to do something like this:

Foo::Foo(int a, int b)
{
bar = Bar(a);
baz = Baz(b);
}

Or alternatively use bar.set(a) or something like that. This means that
in a worst case scenario you have to run the constructors of Bar and Baz
twice just to create one Foo object. If you use an initialisation-list
instead bar and baz will be constructed with the correct parameters
before the body of Foo's constructor is executed.

You can never get better performance by not using initialisation-lists,
but you can sometimes get the same performance.

 

[James Kanze]

On 2008-01-16 08:09, Jack Klein wrote:

No it does not, but it does guarantee some other things that
makes it very probably that using the initialiser-list if
slightly more efficient.

Or not. The cases where there is a measurable difference are
probably fairly rare.

[...]

You can never get better performance by not using
initialisation-lists, but you can sometimes get the same
performance.

I wouldn't say never---if I tried, I'm sure I could write some
perverse code where default construction followed by assignment
was faster than direct construction. Most of the time, however,
there's just no difference.

Performance isn't the motivation for initializer lists, however.
The motivation is security---not having uninitialized variables
floating around. (This isn't quite true, as the initialization
expressions can reference other member variables---including
those not yet initialized. But using initialization lists does
reduce the risk enormously.)

 

[Marc]

How can we justify that initializer list is better in performance

than assignment list in constructor of C++ ??

http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.6