"Default constructor" for built-in types

Discussion in 'C++' started by Pierre Senellart, Jan 25, 2005.

  1. The C++ standard states (26.3.2.1), about std::valarray constructors:

    > explicit valarray(size_t);
    >
    > The array created by this constructor has a length equal to the value of
    > the argument. The elements of the array are constructed using the default
    > constructor for the instantiating type T.


    Does that mean that, on built-in types (e.g. int), "default
    initialization" (as described in 8.5) is performed?

    Thanks,

    --
    Pierre Senellart
     
    Pierre Senellart, Jan 25, 2005
    #1
    1. Advertising

  2. Pierre Senellart wrote:
    > > The array created by this constructor has a length equal to the

    value of
    > > the argument. The elements of the array are constructed using the

    default
    > > constructor for the instantiating type T.

    >
    > Does that mean that, on built-in types (e.g. int), "default
    > initialization" (as described in 8.5) is performed?


    Yes. Effectively, it means that for POD types (which includes the
    built-in types) the values are zero initialized.
    --
    <mailto:> <http://www.dietmar-kuehl.de/>
    <http://www.contendix.com> - Software Development & Consulting
     
    Dietmar Kuehl, Jan 26, 2005
    #2
    1. Advertising

  3. Pierre Senellart

    Mark Guest

    >
    > Yes. Effectively, it means that for POD types (which includes the
    > built-in types) the values are zero initialized.


    I'm confused. I ran a test. When compiling a .cpp file, my compiler
    warns about uninitialised variables, and the values assigned to
    them are random which is shown when I print them out.

    I'm using MSVC++ 6.0

    Although MSVC++ 6.0 has STL does anyone know if it breaks
    the standard in this respect. It seems such a fundemental rule,
    then I would expect it not to. But then again, see above.


    Mark
     
    Mark, Jan 26, 2005
    #3
  4. Mark wrote:
    >>Yes. Effectively, it means that for POD types (which includes the
    >>built-in types) the values are zero initialized.

    >
    >
    > I'm confused. I ran a test. When compiling a .cpp file,


    Care to share the file with us?

    > my compiler
    > warns about uninitialised variables, and the values assigned to
    > them are random which is shown when I print them out.
    >
    > [...]
     
    Victor Bazarov, Jan 26, 2005
    #4
  5. Pierre Senellart

    Mark Guest


    >
    > Care to share the file with us?
    >


    something as simple as:

    #include <iostream>
    using namespace std;

    unsigned int main(unsigned int argc,
    char* argv[])
    {
    unsigned int i;

    cout << i << endl;

    return 0;
    }

    I get
    warning:local variable 'i' is used without being initialized.
    The program outputs what ever value was in memory at the
    time.


    Mark
     
    Mark, Jan 27, 2005
    #5
  6. "Mark" <> wrote...
    >
    >>
    >> Care to share the file with us?
    >>

    >
    > something as simple as:
    >
    > #include <iostream>
    > using namespace std;
    >
    > unsigned int main(unsigned int argc,
    > char* argv[])
    > {
    > unsigned int i;
    >
    > cout << i << endl;
    >
    > return 0;
    > }
    >
    > I get
    > warning:local variable 'i' is used without being initialized.
    > The program outputs what ever value was in memory at the
    > time.


    Yes. Why are you surprised? To initialise the variable you need
    to write

    unsigned int i(42); // or whatever value you prefer

    V
     
    Victor Bazarov, Jan 27, 2005
    #6
  7. Pierre Senellart

    Mark Guest

    >
    > Yes. Why are you surprised? To initialise the variable you need
    > to write
    >
    > unsigned int i(42); // or whatever value you prefer
    >


    _because in the context of the previous post_,

    > Does that mean that, on built-in types (e.g. int), "default
    > initialization" (as described in 8.5) is performed?


    Yes. Effectively, it means that for POD types (which includes the
    built-in types) the values are zero initialized.

    I was expecting

    unsigned int i;

    to have a default initialiser of zero.

    Basically I just need to clear up my understanding of the standard
    behaviour, and work out where my misunderstanding lies.
    In practice , I always endeavour to explicitly initialise my vars
    re: best practice, so it would'nt normally be a problem.

    Mark
     
    Mark, Jan 27, 2005
    #7
  8. "Mark" <> wrote...
    > >
    >> Yes. Why are you surprised? To initialise the variable you need
    >> to write
    >>
    >> unsigned int i(42); // or whatever value you prefer
    >>

    >
    > _because in the context of the previous post_,
    >
    >> Does that mean that, on built-in types (e.g. int), "default
    >> initialization" (as described in 8.5) is performed?

    >
    > Yes. Effectively, it means that for POD types (which includes the
    > built-in types) the values are zero initialized.


    In the 'valarray's constructor, yes. Just like in the 'vector's
    constructor, for example.

    > I was expecting
    >
    > unsigned int i;
    >
    > to have a default initialiser of zero.


    WHY? The 'i' variable here is not _default_-initialised. It is
    _uninitialised_. In the statement above there is no _initialiser_.
    Read 8.5/9, it should be clear enough.

    > Basically I just need to clear up my understanding of the standard
    > behaviour, and work out where my misunderstanding lies.


    Do you have a copy of the Standard? Then read 8.5 carefully. If
    you don't have a copy of the Standard, how do you expect to clear
    up your understanding of it?

    > In practice , I always endeavour to explicitly initialise my vars
    > re: best practice, so it would'nt normally be a problem.


    That's called "avoiding the issue".

    V
     
    Victor Bazarov, Jan 27, 2005
    #8
  9. Mark wrote:
    > #include <iostream>
    > using namespace std;
    >
    > unsigned int main(unsigned int argc,


    BTW, the return type of 'main()' is 'int' according to
    the standard, not 'unsigned int'. The same applies to
    the first argument.

    > char* argv[])
    > {
    > unsigned int i;
    >
    > cout << i << endl;
    >
    > return 0;
    > }


    I don't see any mention of 'valarray' in this file. Also,
    I don't see any trace of default initializing a built-in
    value. Default initialization is typically requested by
    tagging a pair of parenthesis on the appropriate type or
    member. For example:

    /**/ template <typename T>
    /**/ struct foo {
    /**/ foo():
    /**/ member() // <--- this is default initialization
    /**/ {}
    /**/ T member;
    /**/ };

    You can try it out: if you instantiated this class with an
    'unsigned int' (or some other built-in type) it should always
    be zero. You can also verify that without the default
    initialization the value of 'member' is not necessarily zero
    (although there is no guarantee that it is not initialized)
    if you remove the mention of 'member' in the member
    initializer list. Here is a small program displaying this:

    /**/ #include <new>
    /**/ #include <iostream>
    /**/ int main() {
    /**/ void* mem = operator new(sizeof(foo<int>));
    /**/ foo<int>* obj = new(mem) foo<int>;
    /**/ std::cout << obj->member << "\n";
    /**/ obj->member = 17;
    /**/ obj->~foo<int>();
    /**/ obj = new(mem) foo<int>;
    /**/ std::cout << obj->member << "\n";
    /**/ obj->~foo<int>();
    /**/ operator delete(mem);
    /**/ }

    For members with class types the default initialization is kind
    of redundant because it would happen even if the member was not
    mentioned in the member initializer list. For members with
    built-in, POD, or aggregate types it makes a difference though:
    these stay uninitialized (for aggregates only members of POD
    or built-in types would be uninitialized; aggregate members
    with class type are, of course, default constructed).
    --
    <mailto:> <http://www.dietmar-kuehl.de/>
    <http://www.contendix.com> - Software Development & Consulting
     
    Dietmar Kuehl, Jan 27, 2005
    #9
  10. Pierre Senellart

    Ron Natalie Guest

    There's no "default" constructor for non-class types, but there
    is default (zero) initialization. Unfortunately, for braindead
    compatibility with C, the default initialization is NOT done for
    POD types in the following circumstances:

    Naked (i.e., declared without initializers) variables local to
    a class or function.

    dynamically allocated instances.

    However, in other places (notably static variables) and in the
    case of anything given the empty initializer paramters (when
    that is valid), gets the default (zero) initialization.
     
    Ron Natalie, Jan 27, 2005
    #10
    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. Aire
    Replies:
    3
    Views:
    474
    Mike Wahler
    Jan 25, 2004
  2. Replies:
    9
    Views:
    979
    Alf P. Steinbach
    Mar 6, 2006
  3. Replies:
    4
    Views:
    423
    Salt_Peter
    Oct 12, 2006
  4. Alona
    Replies:
    2
    Views:
    658
  5. Generic Usenet Account
    Replies:
    10
    Views:
    2,281
Loading...

Share This Page