Standard behaviour ?

[Ares Lagae]

Could someone please tell me what the behaviour of the following code
snippet is, according to the C++ standard ?

--------------------------------------------------------------------------

#include <iostream>

template <class T>
class Foo
{
public:
T m_f;
Foo(T f) : m_f(f) {}
//Foo(const Foo & foo) : m_f(foo.m_f) {}
static const Foo CONST;
};

template <class T>
const Foo<T> Foo<T>::CONST = Foo(T(1));

class Bar
{
public:
Foo<float> m_foo;
Bar() : m_foo(Foo<float>::CONST)
{
std::cout << "Foo.m_f = " << m_foo.m_f << std::endl;
}
};

Bar bar;

int main(int argc, char * argv[])
{
Bar bar;
return 0;
}

--------------------------------------------------------------------------------

On some compilers it prints "0 1", as if the static constant was not
initialized the first time, and on some compilers it prints "1 1".
I *think* (i hope not, but i could be wrong here) than the standard
behaviour is to print "1 1".
If this is in fact the case, there is a bug in each version of the MS C
compiler (tested with MSVC 6.0 and MSVC 7.0), the Intel compiler (tested
with ICC7.0/win), and in some versions of GCC (with gcc 3.3 it does
seems to work). If this is in fact a bug, is this bug known ?

Best regards,
Ares Lagae

 

[Ares Lagae]

Could someone please tell me what the behaviour of the following code
snippet is, according to the C++ standard ?

guess i was to fast to post, sorry

because both Bar bar and Foo::CONST are statics, there is no order
defined in which they are initialized ... so the behaviour according to
the standard is undefined. It just took me a while to realize that

best regards,
Ares Lagae

 

[Peter Koch Larsen]

guess i was to fast to post, sorry

because both Bar bar and Foo::CONST are statics, there is no order
defined in which they are initialized ... so the behaviour according to
the standard is undefined. It just took me a while to realize that

best regards,
Ares Lagae

This is not entirely correct - within a translation unit (one source file),
the order is well defined. However, I do have some severe reservation wrt
your definition of templated static members - i have never used those myself
and wonder if they have any consequences for the initialization.

Kind regards
Peter Koch Larsen

 

[Victor Bazarov]

guess i was to fast to post, sorry

because both Bar bar and Foo::CONST are statics, there is no order
defined in which they are initialized ... so the behaviour according to
the standard is undefined. It just took me a while to realize that

Actually, I don't think so. The global 'bar' causes the constructor to
be called. In the constructor the initialisation list causes the static
member of the Foo template to be implicitly defined (per 14.7.1/1) which
causes the initialisation of it to float(1). The 'm_foo' member is then
initialised with the value of the 'CONST', which has been itself
initialised to 1f. Therefore, the output has to be

Foo.m_f = 1
Foo.m_f = 1

If you have any proof of why the behaviour is undefined, do tell.

Victor

 

[Ares Lagae]

Actually, I don't think so. The global 'bar' causes the constructor to

be called. In the constructor the initialisation list causes the static
member of the Foo template to be implicitly defined (per 14.7.1/1) which
causes the initialisation of it to float(1). The 'm_foo' member is then
initialised with the value of the 'CONST', which has been itself
initialised to 1f. Therefore, the output has to be

Foo.m_f = 1
Foo.m_f = 1

If you have any proof of why the behaviour is undefined, do tell.

If this is indeed the case, then most compilers do not implement this
behaviour. Of the compilers i tested (see my previous post), only the most
recent g++ (3.3) behaved as you describe.

best regards,
Ares Lagae