Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Standard behaviour ?

Reply
Thread Tools

Standard behaviour ?

 
 
Ares Lagae
Guest
Posts: n/a
 
      11-26-2003
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
 
Reply With Quote
 
 
 
 
Ares Lagae
Guest
Posts: n/a
 
      11-26-2003
Ares Lagae wrote:
>
> 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
 
Reply With Quote
 
 
 
 
Peter Koch Larsen
Guest
Posts: n/a
 
      11-26-2003

"Ares Lagae" <(E-Mail Removed)> skrev i en meddelelse
news:(E-Mail Removed)...
> Ares Lagae wrote:
> >
> > 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


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


 
Reply With Quote
 
Victor Bazarov
Guest
Posts: n/a
 
      11-26-2003
"Ares Lagae" <(E-Mail Removed)> wrote...
> Ares Lagae wrote:
> >
> > 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


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


 
Reply With Quote
 
Ares Lagae
Guest
Posts: n/a
 
      11-26-2003
> 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


 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
debugger behaviour different to execution behaviour Andy Chambers Java 1 05-14-2007 09:51 AM
Is input/output stream buffer behaviour random acc. to C++ standard? qazmlp1209@rediffmail.com C++ 2 05-29-2005 03:39 PM
pre, post increment standard behaviour, and friend function declaration eddiew_AUS C++ 18 01-27-2004 04:31 PM
Irregular behaviour: C++ standard lib and file stream. bruce varley C++ 2 11-25-2003 05:27 PM
Standard behaviour of a getSomething method Batista, Facundo Python 2 07-23-2003 11:19 PM



Advertisments