"Default constructor" for built-in types

[Pierre Senellart]

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,

 

[Dietmar Kuehl]

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.

 

[Mark]

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

 

[Victor Bazarov]

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.

[...]

 

[Mark]

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

 

[Victor Bazarov]

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

 

[Mark]

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

 

[Victor Bazarov]

_because in the context of the previous post_,


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

 

[Dietmar Kuehl]

#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).

 

[Ron Natalie]

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.