By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
434,945 Members | 1,692 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 434,945 IT Pros & Developers. It's quick & easy.

Default & Value Initialization

P: n/a
Dear all,

Can somebody direct me to some resources on the subject or explain the
details in brief? I checked the FAQ but could not find or maybe missed.

Regards,

Jun 20 '06 #1
Share this Question
Share on Google+
10 Replies


P: n/a
utab wrote:
Dear all,

Can somebody direct me to some resources on the subject or explain the
details in brief? I checked the FAQ but could not find or maybe missed.

What subject?

Are there any specifics you are unsure of?

--
Ian Collins.
Jun 20 '06 #2

P: n/a

What subject?


intialization(for example:ctors for class types)

In general, I read something but not completely clear to me. (I read
some parts from Accelerated C++.)

Jun 20 '06 #3

P: n/a

utab wrote:
What subject?


intialization(for example:ctors for class types)

In general, I read something but not completely clear to me. (I read
some parts from Accelerated C++.)


I have not read Accelerated C++.
Try reading Effective C++, this book helped me understand
initialization better.

~Madhav

Jun 20 '06 #4

P: n/a
utab wrote:
What subject?

intialization(for example:ctors for class types)

In general, I read something but not completely clear to me. (I read
some parts from Accelerated C++.)

That's a very broad subject for a Usenet posting, are there any specific
areas you'd like clarified?

--
Ian Collins.
Jun 20 '06 #5

P: n/a

That's a very broad subject for a Usenet posting, are there any specific
areas you'd like clarified?


Is there a source that you may direct me for a wider discussion so that
I may spend some time on that myself and then return here if there are
points uncertain to me.

Regards,

Jun 20 '06 #6

P: n/a
utab wrote:
Dear all,

Can somebody direct me to some resources on the subject or explain the
details in brief? I checked the FAQ but could not find or maybe missed.


Value initialization was in the 2003 update to the standard, and is
therefore not covered in any books I know of (though surely there is
one). The best source would probably be the draft C++0x standard, here:
http://www.open-std.org/jtc1/sc22/wg...2005/n1905.pdf

See section 8.5.

Tom
Jun 20 '06 #7

P: n/a
utab wrote:
That's a very broad subject for a Usenet posting, are there any specific
areas you'd like clarified?

Is there a source that you may direct me for a wider discussion so that
I may spend some time on that myself and then return here if there are
points uncertain to me.

I can only suggest the book you have and "The C++ Programming Language".

--
Ian Collins.
Jun 20 '06 #8

P: n/a
"utab" <um********@gmail.com> wrote in message
news:11*********************@i40g2000cwc.googlegro ups.com...
Can somebody direct me to some resources on the subject or explain the
details in brief? I checked the FAQ but could not find or maybe missed.


Here is a very brief summary:

When a type name or constructor initializer is followed by () [i.e. a pair
of parentheses with only whitespace between them], that calls for value
initialization. The difference between value initialization and the way
local variables are initialized is that value initialization gives an
initial value of zero to members that are out of reach of any constructor.

Here is an example:

struct A {
int x;
int y;
};

struct B {
int x;
std::string s;
};

struct C {
int x;
int y;
C() { }
};

If we write the following:

void foo()
{
A a;
B b;
C c;
}

then the local variables a, b, and c are all default-initialized. That
means that a.x and a.y, b.x, c.x, and c.y all have undefined values. On the
other hand, b.s is initialized to a null string, because that is what the
std::string constructor does.

Now, suppose we do this:

void bar()
{
A a = A();
B b = B();
C c = C(); // undefined behavior!
}

In each case we are value-initializing an otherwise nameless object (by
writing A(), B(), and C() respectively), and copying the value of that
object to the appropriate local variable.

In the case of A(), the x and y members will both be set to zero, because
they are out of reach of any constructor.

In the case of B(), the x member will be set to zero, for exactly the same
reason as the x member of A(); the s member will be initialized to a null
string by its own constructor.

In the case of C(), there is a constructor that is capable of initializing
the x and y members, so no initialization takes place. Attempting to copy
C() to c therefore results in undefined behavior.

The idea behind value initialization is that it takes place when an object
is about to be used in a context that demands a value--that is, when it is
about to be copied. When I write

A a;

there is no request to copy the variable "a", but when I write

A a = A();

there is a request to copy the nameless object represented by A(). For
example, if I had written

int x = int();

this definition would have undefined behavior unless int() had a
well-defined value, so int() is value-initialized to zero.

Incidentally, it would have a totally different meaning if I were to write

A a();

which would declare "a" as a function with no arguments returning an object
of type A.

As for constructor initializers:

struct S {
A a;
S(): a() { }
};

The member initializer "a" is followed by a pair of parentheses, so this
example demands value initialization. In other words, if I write

void foo()
{
S s;
}

then s.a.x and s.a.y will both be initialized to zero because of value
initialization.
Jun 21 '06 #9

P: n/a
Andrew Koenig wrote:
"utab" <um********@gmail.com> wrote in message
news:11*********************@i40g2000cwc.googlegro ups.com...
Can somebody direct me to some resources on the subject or explain the
details in brief? I checked the FAQ but could not find or maybe missed.


Here is a very brief summary:

When a type name or constructor initializer is followed by () [i.e. a pair
of parentheses with only whitespace between them], that calls for value
initialization. The difference between value initialization and the way
local variables are initialized is that value initialization gives an
initial value of zero to members that are out of reach of any constructor.

Here is an example:

struct A {
int x;
int y;
};

struct B {
int x;
std::string s;
};

struct C {
int x;
int y;
C() { }
};

If we write the following:

void foo()
{
A a;
B b;
C c;
}

then the local variables a, b, and c are all default-initialized. That
means that a.x and a.y, b.x, c.x, and c.y all have undefined values. On the
other hand, b.s is initialized to a null string, because that is what the
std::string constructor does.


Your terminology seems to differ from what I see in the standard. From
8.5.5, "To default-initialize an object of type T means: [special rules
for non-POD class types and array types]; otherwise, the object is
zero-initialized."

Then in 8.5.9, "If no initializer is specified for an object [special
rules for non-POD class types]. Otherwise, if no initializer is
specified for a non-static object, the object and its subobjects, if
any, have an indeterminate initial value."

In my view, "default initialization" should never leave an object with
undefined values.

-Mark
Jun 21 '06 #10

P: n/a
Mark P wrote:
Andrew Koenig wrote:
Your terminology seems to differ from what I see in the standard. From
8.5.5, "To default-initialize an object of type T means: [special rules
for non-POD class types and array types]; otherwise, the object is
zero-initialized."

Then in 8.5.9, "If no initializer is specified for an object [special
rules for non-POD class types]. Otherwise, if no initializer is
specified for a non-static object, the object and its subobjects, if
any, have an indeterminate initial value."

In my view, "default initialization" should never leave an object with
undefined values.


The paragraphs you quote changed in the 2003 standard:
8.5/5:
To zero-initialize an object of type T means:
— if T is a scalar type (3.9), the object is set to the value of 0
(zero) converted to T;
— if T is a non-union class type, each nonstatic data member and each
base-class subobject is zeroinitialized;
— if T is a union type, the object’s first named data member89) is
zero-initialized;
— if T is an array type, each element is zero-initialized;
— if T is a reference type, no initialization is performed.

To default-initialize an object of type T means:
— if T is a non-POD class type (clause 9), the default constructor for T
is called (and the initialization is ill-formed if T has no accessible
default constructor);
— if T is an array type, each element is default-initialized;
— otherwise, the object is zero-initialized.

To value-initialize an object of type T means:
— if T is a class type (clause 9) with a user-declared constructor
(12.1), then the default constructor for T is
called (and the initialization is ill-formed if T has no accessible
default constructor);
— if T is a non-union class type without a user-declared constructor,
then every non-static data member
and base-class component of T is value-initialized;
— if T is an array type, then each element is value-initialized;
— otherwise, the object is zero-initialized.

Tom
Jun 22 '06 #11

This discussion thread is closed

Replies have been disabled for this discussion.