Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > "Default constructor" for built-in types

Reply
Thread Tools

"Default constructor" for built-in types

 
 
Pierre Senellart
Guest
Posts: n/a
 
      01-25-2005
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
 
Reply With Quote
 
 
 
 
Dietmar Kuehl
Guest
Posts: n/a
 
      01-26-2005

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.
--
<(E-Mail Removed)> <http://www.dietmar-kuehl.de/>
<http://www.contendix.com> - Software Development & Consulting

 
Reply With Quote
 
 
 
 
Mark
Guest
Posts: n/a
 
      01-26-2005
>
> 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





 
Reply With Quote
 
Victor Bazarov
Guest
Posts: n/a
 
      01-26-2005
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.
>
> [...]

 
Reply With Quote
 
Mark
Guest
Posts: n/a
 
      01-27-2005

>
> 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


 
Reply With Quote
 
Victor Bazarov
Guest
Posts: n/a
 
      01-27-2005
"Mark" <(E-Mail Removed)> 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


 
Reply With Quote
 
Mark
Guest
Posts: n/a
 
      01-27-2005
>
> 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


 
Reply With Quote
 
Victor Bazarov
Guest
Posts: n/a
 
      01-27-2005
"Mark" <(E-Mail Removed)> 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


 
Reply With Quote
 
Dietmar Kuehl
Guest
Posts: n/a
 
      01-27-2005
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).
--
<(E-Mail Removed)> <http://www.dietmar-kuehl.de/>
<http://www.contendix.com> - Software Development & Consulting

 
Reply With Quote
 
Ron Natalie
Guest
Posts: n/a
 
      01-27-2005
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.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Can XSD simple types be derived from complex types? Soren Kuula XML 2 12-01-2005 07:51 PM
Where are ref types that are members of value types stored? Sathyaish ASP .Net 2 05-22-2005 07:32 PM
missing types in module types? Manlio Perillo Python 0 05-29-2004 06:33 AM
Boost + Python C/API: Mixing python return types with boost return types Steve Knight Python 2 10-10-2003 10:11 AM
STD types vs C++ intrinsic types Jeremy Cowles C++ 5 08-19-2003 05:33 PM



Advertisments