467,161 Members | 848 Online
Bytes | Developer Community
Ask Question

Home New Posts Topics Members FAQ

Post your question to a community of 467,161 developers. It's quick & easy.

"Default constructor" for built-in types

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
Jul 23 '05 #1
  • viewed: 3301
Share:
9 Replies

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:di***********@yahoo.com> <http://www.dietmar-kuehl.de/>
<http://www.contendix.com> - Software Development & Consulting

Jul 23 '05 #2
>
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

Jul 23 '05 #3
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.

[...]

Jul 23 '05 #4

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
Jul 23 '05 #5
"Mark" <ms******@REMOVETHISBITbtinternet.com> 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
Jul 23 '05 #6
>
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
Jul 23 '05 #7
"Mark" <ms******@REMOVETHISBITbtinternet.com> 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
Jul 23 '05 #8
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:di***********@yahoo.com> <http://www.dietmar-kuehl.de/>
<http://www.contendix.com> - Software Development & Consulting

Jul 23 '05 #9
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.
Jul 23 '05 #10

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

3 posts views Thread by C# Learner | last post: by
1 post views Thread by Brian | last post: by
1 post views Thread by Jeff Brown | last post: by
3 posts views Thread by per9000 | last post: by
1 post views Thread by Simon van Beek | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.