Default & Value Initialization

Discussion in 'C++' started by utab, Jun 20, 2006.

  1. utab

    utab Guest

    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,
     
    utab, Jun 20, 2006
    #1
    1. Advertising

  2. utab

    Ian Collins Guest

    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.
     
    Ian Collins, Jun 20, 2006
    #2
    1. Advertising

  3. utab

    utab Guest


    > 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++.)
     
    utab, Jun 20, 2006
    #3
  4. utab

    coder22 Guest

    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
     
    coder22, Jun 20, 2006
    #4
  5. utab

    Ian Collins Guest

    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.
     
    Ian Collins, Jun 20, 2006
    #5
  6. utab

    utab Guest


    > 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,
     
    utab, Jun 20, 2006
    #6
  7. utab

    Tom Widmer Guest

    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/wg21/docs/papers/2005/n1905.pdf

    See section 8.5.

    Tom
     
    Tom Widmer, Jun 20, 2006
    #7
  8. utab

    Ian Collins Guest

    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.
     
    Ian Collins, Jun 20, 2006
    #8
  9. "utab" <> wrote in message
    news:...

    > 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.
     
    Andrew Koenig, Jun 21, 2006
    #9
  10. utab

    Mark P Guest

    Andrew Koenig wrote:
    > "utab" <> wrote in message
    > news:...
    >
    >> 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
     
    Mark P, Jun 21, 2006
    #10
  11. utab

    Tom Widmer Guest

    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
     
    Tom Widmer, Jun 22, 2006
    #11
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. JKop
    Replies:
    10
    Views:
    947
  2. Matthias Kaeppler
    Replies:
    2
    Views:
    445
    Victor Bazarov
    Jul 18, 2005
  3. Jess
    Replies:
    23
    Views:
    929
  4. Jess
    Replies:
    4
    Views:
    444
  5. Taras_96
    Replies:
    3
    Views:
    588
    Michael Tsang
    Oct 30, 2009
Loading...

Share This Page