Thread: int i(0) in a for loop

it seems to be initializing i to zero, but I would suggest not using it...

except int isn't a class.

edit: it's standard code... I just remembered that it's usually used in class constructors to initialize data members. It's an initialization method, so it really shouldn't work after initialization, but you could try it out...

edit2: yeah, it's used only in initialization, and it is called direct initialization.

Originally Posted by ^xor

I recently came across this in some code:

Code:

for (int i(0); i<10; i++)
        cout << i << endl;

What does i(0) do?

It takes up one more character than "i=0". Other than that, it's the same.


Quzah.

Here? Probably nothing. Your compiler will usually optimize things fairly good. Often times better than you would were you trying. In cases like this, the difference isn't worth the time spent talking about it. But I'm sure some one here, if they feel motivated enough, will vomit up some assembly output of the two, which usually depends on your compiler flags anyway..


Quzah.

I'm not too sure of this myself, so what I write is from the book "C++ Gotchas" by Stephen Dewhurst, 2003. (Gotcha #56, pages 153-156)
Dewhurst gives the following class example:

Code:

class Y {
public:
	Y(int);
	~(Y);
};

He then presents 3 initializations of a Y object:

Code:

Y a(1066);
Y b = Y(1066);
Y c = 1066;

Dewhurst then proceeds to claim that:

In point of fact, all three of these initializations will probably result in the same object code being generated, but they're not equivalent. The initialization of a is known as a direct initialization, and it does precisely what one might expect. The initialization is accomplished through a direct invocation of Y::Y(int).

The initializations of b and c are more complex. In fact, they're too complex. These are both copy initializations. In the case of the initialization of b, we're requesting the creation of an anonymous temporary of type Y, initialized with the value 1066. We then use this anonymous temporary as a parameter to the copy constructor for class Y to initialize b. Finally, we call the destructor for the anonymous temporary.

...

The semantics of the initialization of c are the same, but the creation of the anonymous temporary is implicit.

Dewhurst proceeds to change the declaration of Y to include a copy constructor that calls abort(). He then notes that chances are, all three initializations work without terminating the process.

He explains this by writing:

What gives is that the standard explicitly allows the compiler to perform a program transformation to remove the temporary generation and copy constructor call and to generate the same code as in the case of a direct initialization. Note that this is not a simple "optimization", since the actual behavior of the program is altered (in this case, we didn't terminate the process). Most C++ compilers will perform the transformation, but they're not required to do so by the standard.

Now, for the int i(0) example, I think the situation is different. We are dealing with a fundamental type in C++, and furthermore using an integer literal to initialize an integer. In Dewhurst's example, it would be like using a Y literal to initialize a Y object - but of course Y literals dont exist in C++.