Re: array initialiser list, order of initialisation
In article <48768727$1_4@mk-nntp-2.news.uk.tiscali.com>,
andy@servocomm.freeserve.co.uk says...
Hi,
In the following code, the initialisation of the array elements depends on
the first in the initialiser list being initialised before the second and so
on. Can I rely on that?
#include <iostream>
int main()
{
int ar[3] = {
1,
ar[0]+1,
ar[1]+1
};
std::cout
<< ar[0] << ' '
<< ar[1] << ' '
<< ar[2] << '\n';
}
As far as I can see, no. IF this used dynamic initialization, you'd be
guaranteed that the objects in the array would be initialized in order,
and you'd be guaranteed that there was a sequence point between each
initialization and the next, so you'd get defined results.
What you have, however, is an array of items (ints) with no user-
declared constructors, no private or protected non-static members, no
base classes and no virtual functions. That means what you have is an
aggregate, which is static initialized.
The only guarantee made about order of static initialization is that it
happens before dynamic initialization. As such, your code currently has
undefined behavior -- it could work for some compilers, and fail for
others, or change behavior based on the compilation flags you use, or
whatever.
It is, however, trivial to make it work correctly: instead of int's,
create an array of proxy objects that act like ints:
class Int {
int value;
public:
Int(int v) : value(v) {}
operator int &() { return value; }
};
Int ar[3] = {
1,
ar[0] + 1,
ar[1] + 1
};
Since this has a user-declared ctor, it's not an aggregate. Since it's
not an aggregate, you get dynamic initialization instead of static
initialization. Dynamic initialization guarantees that the
initialization happens in order, with a sequence point between each
initialization and the next. IOW, it works.
As far as speed goes, I'm reasonably certain any decent compiler will
produce identical code for manipulation thsese objects as it would for
raw ints. For example, given code like:
int total = 0;
for (int i=0; i<3; i++)
total += ar[i];
There is no difference between the code produced if ar is an array of
int or of Int. Of course, that theoretically applies only to the
compilers I tested -- in theory, some other compiler _could_ produce
different code, though I'd be rather surprised to see it. Offhand, I
can't really think of what it _could_ reasonably change...
--
Later,
Jerry.
The universe is a figment of its own imagination.