what is the default constructor for the POD type

[Stanley Rice]

I want to know the *default constructor* for the POD type. Since STL
implement some of the function based on the type of the paramter, fill_n
for example, may have different implementation, one for the POD type, where
no constructor will be called, and other for non-POD type. So I wrote the
code:
vector<int> vec(5);
and follow the debugger. Finlly, I come across a function:

template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __n > 0; --__n, ++__first)
*__first = __tmp;
return __first;
}

which is defined in stl_algobse.h. I print out the value of the parameter
*__value* and the result is:
(const int &) @0xbffff338: 0
and the value of __tmp is: 0

I didn't initialize the __value, so I think the value of variable __value
should be *random*, just like a normal variable definition without
initializaion. But, here the value is always 0, Why?

Thanks.

 

[Alf P. Steinbach]

I want to know the *default constructor* for the POD type. Since STL
implement some of the function based on the type of the paramter, fill_n
for example, may have different implementation, one for the POD type, where
no constructor will be called, and other for non-POD type. So I wrote the
code:
vector<int> vec(5);
and follow the debugger. Finlly, I come across a function:

template<typename _OutputIterator, typename _Size, typename _Tp>
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __n> 0; --__n, ++__first)
*__first = __tmp;
return __first;
}

which is defined in stl_algobse.h. I print out the value of the parameter
*__value* and the result is:
(const int&) @0xbffff338: 0
and the value of __tmp is: 0

I didn't initialize the __value, so I think the value of variable __value
should be *random*, just like a normal variable definition without
initializaion. But, here the value is always 0, Why?

Thanks.

`std::vector` guarantees to initialize its elements.

If you don't provide an initial value then the default one for type T is
T().

And writing int() is the same as writing 0. It is an example of *pseudo
constructor* notation. As I recall, the standard does not define or use
that term, but does talk about "pseudo destructor" for the corresponding
notation for destruction (which you can't apply directly to an int).

So, it's not compiler specific behavior that you're seeing.

The initialization is guaranteed by std::vector, and the particular
value for the int type, namely 0, is specified elsewhere in the standard.


Cheers & hth.,

- Alf

 

[Goran]

I want to know the *default constructor* for the POD type. Since STL
implement some of the function based on the type of the paramter, fill_n
for example, may have different implementation, one for the POD type, where
no constructor will be called, and other for non-POD type. So I wrote the
code:
    vector<int> vec(5);
and follow the debugger. Finlly, I come across a function:

template<typename _OutputIterator, typename _Size, typename _Tp>
  inline typename
  __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
  __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
  {
    const _Tp __tmp = __value;
    for (; __n > 0; --__n, ++__first)
      *__first = __tmp;
    return __first;
  }

which is defined in stl_algobse.h. I print out the value of the parameter
*__value* and the result is:
    (const int &) @0xbffff338: 0
and the value of __tmp is: 0

I didn't initialize the __value, so I think the value of variable __value
should be *random*, just like a normal variable definition without
initializaion. But, here the value is always 0, Why?

Seeing that I am the one who said to step through with debugger in
another thread, it's my fault for what you did ;-).

However, in that thread, you said that you wanted to know _how_ STL is
implemented, but here, the question is _what_ STL should be doing. And
for that, you read the documentation ;-).

Basically, when resizing (even during construction), vector default-
initializes it's elements. For "primitive" types, that means setting
to 0.

As Alf hinted, C++ can do this:

int i; // i==random memory contents. Primitive and POD types can start
their life like this, uninitialized.

and this:

int i(); // i==0. This is default initialization.

Goran.

 

[Melissa]

int i(); // i==0. This is default initialization.

It looks like function declaration...

 

[Asger Joergensen]

Hi Goran

As Alf hinted, C++ can do this:

int i; // i==random memory contents. Primitive and POD types can start
their life like this, uninitialized.

and this:

int i(); // i==0. This is default initialization.

Not true, that is a function declaration not an initialization.

int i = 0;
will initialize i to 0

and if You have more then on:

int i[10] = {0};
now they are all initialized to 0

Best regards
Asger-P

 

[Alf P. Steinbach]

As Alf hinted, C++ can do this:

int i; // i==random memory contents. Primitive and POD types can start
their life like this, uninitialized.

and this:

int i(); // i==0. This is default initialization.

Well, it would be, except that that latter is a function declaration.

It's "the most vexing parse" of C++.

However,

int i = int();

initializes i with the int default value.

Which is not quite the same as the /formal/ term "default
initialization" means, but near enough: it's initialization, and it's
the default value.


Cheers & hth.,

- Alf