Object Initialisation

[Frederick Gotham]

I have just been reading 8.5 in the Standard, and am trying to make sense
of the different kinds of initialisations .

Up until now, I thought of an object as either NOT being initialised (i.e.
containing garbage), or being default initialised (i.e. containing the
default value for that type).

Here are some examples of the former:

struct MyStruct {

int a;
double b;
void *p;
};

int main()
{
int a; /* Contains garbage */

double b; /* Contains garbage */

void *p; /* Contains garbage */

MyStruct obj; /* All members contain garbage */
}
And here are some examples of the latter:

struct MyStruct {

int a;
double b;
void *p;
};
int main()
{
int a = int(); /* Contains 0 */

double b = double(); /* Contains 0.0 */

typedef void *voidptr;
void *p = voidptr(); /* Contains null pointer value */

MyStruct obj = {}; /* Each member has the same values as above */
}

The Standard tells me that there are three kinds of initialisation:
Zero-initialisation
Default-initialisation
Value-initialisation
In my above code snippet, what kind of initialisation am I peforming? I
think it's "default initialisation" , as I'm giving the object its default
value.

What is zero-initialisation, and can anyone give an example of it please?

What is value-initialisation, and can anyone give an example of it please?
Also, what kind of initialisation does the following class perform?

template<class T>
struct Init {

T obj;

Init() : obj() {}
};

--

Frederick Gotham

[Victor Bazarov]

Frederick Gotham wrote:

I have just been reading 8.5 in the Standard, and am trying to make
sense of the different kinds of initialisations .

Up until now, I thought of an object as either NOT being initialised
(i.e. containing garbage), or being default initialised (i.e.
containing the default value for that type).

Here are some examples of the former:

struct MyStruct {

int a;
double b;
void *p;
};

int main()
{
int a; /* Contains garbage */

double b; /* Contains garbage */

void *p; /* Contains garbage */

MyStruct obj; /* All members contain garbage */
}
And here are some examples of the latter:

struct MyStruct {

int a;
double b;
void *p;
};
int main()
{
int a = int(); /* Contains 0 */

double b = double(); /* Contains 0.0 */

typedef void *voidptr;
void *p = voidptr(); /* Contains null pointer value */

MyStruct obj = {}; /* Each member has the same values as above */
}

The Standard tells me that there are three kinds of initialisation:
Zero-initialisation
Default-initialisation
Value-initialisation

And there is the fourth kind: uninitialised.

In my above code snippet, what kind of initialisation am I peforming?

In the first part, none. Objects are _uninitialised_ . In the second
part the _default_.

I think it's "default initialisation" , as I'm giving the object its
default value.

Right. Only in the second case.

What is zero-initialisation, and can anyone give an example of it
please?

That's the incarnation of the default-initialisation for PODs.

What is value-initialisation, and can anyone give an example of it
please?

int a(5);

Also, what kind of initialisation does the following class perform?

template<class T>
struct Init {

T obj;

Init() : obj() {}
};

Default.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Frederick Gotham]

Victor Bazarov posted:

>What is zero-initialisation, and can anyone give an example of it
please?

That's the incarnation of the default-initialisation for PODs.

The reason we invent words is not so we have a label for something, but so
that we can distinguish it from other things.

That is why I'm confused with "zero-initialsation" Vs. "default-
initialisation" .

Are they not exactly the same? If so, why give them different names?

Can you please give an example of zero-initialising an object?

In the following code, what kind of initialisation takes place?

struct MyStruct {

int a;
double b;
void *p;
};

int main()
{
MyStruct static obj; /* zero or default? */
MyStruct static obj = {}; /* zero or default? */
MyStruct obj = {}; /* zero or default? */
}

--

Frederick Gotham

[Victor Bazarov]

Frederick Gotham wrote:

Victor Bazarov posted:

>>What is zero-initialisation, and can anyone give an example of it
please?

That's the incarnation of the default-initialisation for PODs.

The reason we invent words is not so we have a label for something,
but so that we can distinguish it from other things.

That is why I'm confused with "zero-initialsation" Vs. "default-
initialisation" .

Are they not exactly the same?

No. Yes. For PODs they are the same. For non-PODs they are not
the same.

If so, why give them different names?

Because they are not, in general case.

Can you please give an example of zero-initialising an object?

static int a;
void *p(0);

In the following code, what kind of initialisation takes place?

struct MyStruct {

int a;
double b;
void *p;
};

int main()
{
MyStruct static obj; /* zero or default? */

Zero.

MyStruct static obj = {}; /* zero or default? */

First zero, then default (which in this case superfluous).

MyStruct obj = {}; /* zero or default? */

Default, which for POD is zero-.

}

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Frederick Gotham]

Victor Bazarov posted:

No. Yes. For PODs they are the same. For non-PODs they are not
the same.

Does zero-initialise mean that you explicitly write the numeral figure
zero, as in:

int i = 0;

double b = 0;

int *p = 0;

?
All the above initialisations are equivalent to:
int i = int();

double b = double();

typedef int *intptr;
int *p = intptr();
I still don't understand how zero-initialisation is any different to
default-initialisation. . .
--

Frederick Gotham

[Victor Bazarov]

Frederick Gotham wrote:

Victor Bazarov posted:

>No. Yes. For PODs they are the same. For non-PODs they are not
the same.

Does zero-initialise mean that you explicitly write the numeral figure
zero, as in:

int i = 0;

double b = 0;

int *p = 0;

?

Sort of. '0' is an octal int literal, intialising a 'double' with it
potentially involves a temporary of type 'double' and initialising
a pointer with it potentially involves a temporary null pointer. The
compiler probably does everything behind the scenes and during compile-
time, anyway.

All the above initialisations are equivalent to:
int i = int();

double b = double();

typedef int *intptr;
int *p = intptr();

Right.

I still don't understand how zero-initialisation is any different to
default-initialisation. . .

For non-POD it involves calling the default c-tor. There are no c-tors
for PODs, and that's why there is no difference between 'default-' and
'zero-' for PODs. Just read the Standard.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Sabiyur]

Frederick Gotham wrote:

I have just been reading 8.5 in the Standard, and am trying to make sense
of the different kinds of initialisations .

Up until now, I thought of an object as either NOT being initialised (i.e.
containing garbage), or being default initialised (i.e. containing the
default value for that type).

Here are some examples of the former:

struct MyStruct {

int a;
double b;
void *p;
};

int main()
{
int a; /* Contains garbage */

double b; /* Contains garbage */

void *p; /* Contains garbage */

MyStruct obj; /* All members contain garbage */
}
And here are some examples of the latter:

struct MyStruct {

int a;
double b;
void *p;
};
int main()
{
int a = int(); /* Contains 0 */

double b = double(); /* Contains 0.0 */

typedef void *voidptr;
void *p = voidptr(); /* Contains null pointer value */

MyStruct obj = {}; /* Each member has the same values as above */
}

The Standard tells me that there are three kinds of initialisation:
Zero-initialisation
Default-initialisation
Value-initialisation
In my above code snippet, what kind of initialisation am I peforming? I
think it's "default initialisation" , as I'm giving the object its default
value.

What is zero-initialisation, and can anyone give an example of it please?

What is value-initialisation, and can anyone give an example of it please?
Also, what kind of initialisation does the following class perform?

template<class T>
struct Init {

T obj;

Init() : obj() {}
};

--

Frederick Gotham

Hello Frederick,
I tried your code in VC++ 6.0. It throws compilation
errors.

All the errors point to the code MyStruct obj = {};

\Initialization .cpp(49) : error C2059: syntax error : '}'
\Initialization .cpp(49) : warning C4508: 'main' : function should
return a value; 'void' return type assumed
\Initialization .cpp(53) : error C2143: syntax error : missing ';'
before '}'
\Initialization .cpp(53) : error C2143: syntax error : missing ';'
before '}'
\Initialization .cpp(53) : error C2143: syntax error : missing ';'
before '}'

What compiler are you using?

All,
Is it correct way to initialize the struct like this?

Thanks
Sabiyur

[Victor Bazarov]

Sabiyur wrote:

Frederick Gotham wrote:

>[..]
Frederick Gotham

Hello Frederick,
I tried your code in VC++ 6.0. [..]

Don't. Throw it away. It's so pre-standard, even it's children are
not compliant.

What compiler are you using?

All,
Is it correct way to initialize the struct like this?

Of course. Get a decent compiler. VC++ 2005 EE is available for
free from MS. No comparison, so much better standard compliance.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Frederick Gotham]

Victor Bazarov posted:

>I still don't understand how zero-initialisation is any different to
default-initialisation. . .

For non-POD it involves calling the default c-tor. There are no c-tors
for PODs, and that's why there is no difference between 'default-' and
'zero-' for PODs. Just read the Standard.

I've read the Standard an I don't understand it.

Here's value initialisation:

MyStruct obj = { 1, 5.2, 0 };

Here's default initialisation:

MyStruct obj = {};
So what's zero initialisation?
--

Frederick Gotham

[Victor Bazarov]

Frederick Gotham wrote:

Victor Bazarov posted:

>>I still don't understand how zero-initialisation is any different to
default-initialisation. . .

For non-POD it involves calling the default c-tor. There are no
c-tors for PODs, and that's why there is no difference between
'default-' and 'zero-' for PODs. Just read the Standard.

I've read the Standard an I don't understand it.

Here's value initialisation:

MyStruct obj = { 1, 5.2, 0 };

Here's default initialisation:

MyStruct obj = {};
So what's zero initialisation?

Zero-initialisation is what happens with the POD when you
default-initialise it. So, the last statement is zero-initialisation
(*by definition* of the default-initialisation for PODs). Which part
of it do you not understand?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask