int x; int y; int * ptr; 是不是初始化，对吧？

Question

I'm reading 'C++ All-in-One for Dummies' by JP Mueller and J. Cogswell and stumbled onto this:

#include <iostream>
using namespace std;
int main()
{
    int ExpensiveComputer;
    int CheapComputer;
    int *ptrToComp;
...

This code starts out by initializing all the goodies involved — two integers and a pointer to an integer.

Just to confirm, this is a mistake and should read '... by declaring', right? It's just strange to me that such basic mistakes still make their way to books.

Answer 1

From the point of view of the language, this is default initialization . The problem is, they are initialized to indeterminate values.

otherwise, nothing is done: the objects with automatic storage duration (and their subobjects) are initialized to indeterminate values.

Default initialization of non-class variables with automatic and dynamic storage duration produces objects with indeterminate values (static and thread-local objects get zero initialized)

Note that any attempt to read these indeterminate values leads to UB .

From the standard, [dcl.init]/7

To default-initialize an object of type T means:

• If T is a (possibly cv-qualified) class type ([class]), constructors are considered. The applicable constructors are enumerated ([over.match.ctor]), and the best one for the initializer () is chosen through overload resolution ([over.match]). The constructor thus selected is called, with an empty argument list, to initialize the object.

• If T is an array type, each element is default-initialized.

• Otherwise, no initialization is performed.

Answer 2

Yes you are correct.

You declared and defined these variables, you did not initialize them!

PS: What is the difference between a definition and a declaration?

Answer 3

This code both declares and defines three variables but does not initialize them (their values are said to be indeterminate ).

A variable declaration only must include keyword extern .

Answer 4

Right. Hence, "dummies". :)

We can't even blame this on legacy; historically C programmers would declare* a variable and then "initialize" it later with its first assignment.

But it was never the case that simply declaring a variable, without an initializer, were deemed to be "initializing" it.**

So the wording is just wrong.

_{* Technically we're talking about definitions , but when we say "declare a variable" we almost always mean defining declarations.}

_{** Though objects with static storage duration do undergo their own zero-initialisation phase before anything else happens, so forgoing initialisation yourself is not a catastrophe in that case. Still, we cannot claim that we have initialised that object.}