non-const static member variale initialization

Hello everyone,


Now compiler prevents (at least in Visual Studio 2008) us from initialize non-const static member variable in this way,

Code:

---

Class Foo {
    statuc int i = 200; // compile error, must use const static int i = 200;
    ...
};

---

Anyone know why compiler prevents initialize non-const variable in this way? Any side effects or just a fixed rule from C++ Spec?


thanks in advance,
George

it does but you can get it easily enough.
just put the assignment in the constructor initializer list
basicly

Code:

---

class Foo
{
public:
  Foo();
private:
  static int i;
};

Foo::Foo(/*constructor parameters*/):i(200)
{
  //
}

---

Thanks Raigne,


I just want to initialize the value of the static member variable before any object instances are created. And the value is decided at runtime, so I can not use const.

Any ideas why compiler blocks us initializing non-const static variable?

Quote:

---

Originally Posted by Raigne

it does but you can get it easily enough.
just put the assignment in the constructor initializer list
basicly

Code:

---

class Foo
{
public:
  Foo();
private:
  static int i;
};

Foo::Foo(/*constructor parameters*/):i(200)
{
  //
}

---

---

regards,
George

Because it isn't constant. The value is static, it's a single instance among all instances of the classes, but it's not const, so its value can change.
The reason const variables must be initialized like you do is becuse their value cannot change. A static variable's value, however, can.
If you initialized the constant variables value in the initializer, you'd initialize it every time an instance of the class was constructed! So, a const static variable is an exception, while a mere static isn't.

Quote:

---

Originally Posted by George2

I just want to initialize the value of the static member variable before any object instances are created.

---

If it is private - you cannot access it without creating an instance - so what's the problem?
If it is public - initialize is as any other global variable

Thanks Elysia,


You did not understand my question correctly. My question is not why const static variable must be declared in the way I mentioned, but why non-const variable can not be initialized in the same way how we initialize const static variable.

Any ideas? Let me know if I have not made myself understood.

Quote:

---

Originally Posted by Elysia

Because it isn't constant. The value is static, it's a single instance among all instances of the classes, but it's not const, so its value can change.
The reason const variables must be initialized like you do is becuse their value cannot change. A static variable's value, however, can.
If you initialized the constant variables value in the initializer, you'd initialize it every time an instance of the class was constructed! So, a const static variable is an exception, while a mere static isn't.

---

regards,
George

No vart,


It is public, but we can not initialize in the way below. Do you know why compiler blocks this?

Code:

---

Class Foo {
public:
    statuc int i = 200; // compile error, must use const static int i = 200;
    ...
};

---

Quote:

---

Originally Posted by vart

If it is private - you cannot access it without creating an instance - so what's the problem?
If it is public - initialize is as any other global variable

---

regards,
George

Quote:

---

Originally Posted by George2

Thanks Elysia,

You did not understand my question correctly. My question is not why const static variable must be declared in the way I mentioned, but why non-const variable can not be initialized in the same way how we initialize const static variable.

Any ideas? Let me know if I have not made myself understood.

regards,
George

---

I believe I made myself pretty clear. Const static variables are exceptions and must be initialized in a special way. Mere static variables aren't exceptions and must be initialized the normal way.

Thanks Elysia,


I think I'd better remember it as a fixed C++ rule. Previously, I am thinking if we initialize non-const static variable in the same way (at least could be one of the ways to initialize non-const static variable) as const static variable, there may be some side effects which I have not thought before.

Now I understand it is just a fixed C++ rule and non-const static variable follows the same way as normal variables, except for const static variable.

Quote:

---

Originally Posted by Elysia

I believe I made myself pretty clear. Const static variables are exceptions and must be initialized in a special way. Mere static variables aren't exceptions and must be initialized the normal way.

---

regards,
George

If you think about it logically, there's a reason you can't initialize const static variables in the initializer.
Because for every instance of that object you create, you will initialize the const static variable again. But since there's only one instance of it and it's const, it must be initialized only once.
So that's why it's an exception.

Quote:

---

Originally Posted by George2

No vart,


It is public,

---

Then

Code:

---

class Foo {
public:
    static int i;
};

int Foo::i = 200;

---

just stick with it - or switch to C# ;)

OK, there's far too much nonsense here.

1) You can't initialize any static members in the initializer list. Initializing means giving it an initial value. You can't do that in the per-object constructor for a static variable, obviously.

2) The basic form of initialization for all statics is out-of-line:

Code:

---

class foo
{
  static int bar;
};
int foo::bar; // with an optional initializer here

---

3) Only for constant, integral, static members a special rule exists which says that you can initialize them in-line:

Code:

---

class foo
{
  const static int bar = 200;
};
const int foo::bar; // still required, but initializer now forbidden

---

4) The reason for #2 is consistency. In short, that's just the way it works in C++: globals (and static members are just globals with limited scope and access rights) are given a value at their definition, not their declaration.

5) The reason for #3 is again consistency. C++ allows initialization of global integral constants at the declaration, so that the compiler has the actual value at hand for compile-time calculations.

Thanks CornedBee,


For code like this,

Code:

---

Class Foo{
public:
    int i;
    Foo(): i(100)
    {
    }
};

---

Where do you think is declaration and where do you think is definition of variable i?

Quote:

---

Originally Posted by CornedBee

3) Only for constant, integral, static members a special rule exists which says that you can initialize them in-line:

Code:

---

class foo
{
  const static int bar = 200;
};
const int foo::bar; // still required, but initializer now forbidden

---

---

I do not understand what do you mean "still required"?

Thanks Elysia,

Quote:

---

Originally Posted by Elysia

If you think about it logically, there's a reason you can't initialize const static variables in the initializer.
Because for every instance of that object you create, you will initialize the const static variable again. But since there's only one instance of it and it's const, it must be initialized only once.
So that's why it's an exception.

---

You only explains why we should initialize const static member during declaration, not why we can not initialize non-const statuc member during declaration?

Thanks vart,

Quote:

---

Originally Posted by vart

Then

Code:

---

class Foo {
public:
    static int i;
};

int Foo::i = 200;

---

just stick with it - or switch to C# ;)

---

I know you solution could work. But I am thinking why compiler prevents us from initializing non-const static member variable, whether there are any risk situation which we have never though of -- and compiler will prevent us from such risk situation.


regards,
George

Quote:

---

Originally Posted by George2

I know you solution could work. But I am thinking why compiler prevents us from initializing non-const static member variable, whether there are any risk situation which we have never though of -- and compiler will prevent us from such risk situation.


regards,
George

---

Because the compiler doesn't know where the actual variable will be instantiated at the time of initializer - constants are a different story, as they do not need to change later.

--
Mats

Why Mats?


If we write this,

Code:

---

Class Foo {
public:
    static int i = 100;
};

---

compiler should know i should be initialized before creating any instance of variables, it should function good, if not concerning about optimization.

Why do you say compiler in the case above does not know when to initialize the variable?

Quote:

---

Originally Posted by matsp

Because the compiler doesn't know where the actual variable will be instantiated at the time of initializer - constants are a different story, as they do not need to change later.

--
Mats

---

regards,
George

Quote:

---

Originally Posted by George2

Code:

---

Class Foo{
public:
    int i;
    Foo(): i(100)
    {
    }
};

---

Where do you think is declaration and where do you think is definition of variable i?

---

The declaration is where it says "int i;"
The definition as such doesn't exist. The member is defined as part of the larger object whenever a variable of type Foo is defined.

Quote:

---

I do not understand what do you mean "still required"?

---

As in: just because the initializer is in the class body, doesn't give you the right to omit the definition.

Yes, but what is the location if Foo::i?

I don't actually KNOW why it is, I'm only guessing to the reason - if you really want to know, you are probably best asking Bjarne or someone on the C++ standards committee.

--
Mats

Thanks Mats,

Quote:

---

Originally Posted by matsp

Yes, but what is the location if Foo::i?

Mats

---

I think all static variable should be stored to some global storage, maybe the same as where global variables are stored?

Thanks CornedBee,


Could you show us some code about what do you mean definition of a member variable (not declaration), I am confused.

Quote:

---

Originally Posted by CornedBee

The declaration is where it says "int i;"
The definition as such doesn't exist. The member is defined as part of the larger object whenever a variable of type Foo is defined.


As in: just because the initializer is in the class body, doesn't give you the right to omit the definition.

---

regards,
George

A class declaration is the abstraction of an object, it's not the object itself.
I'm pretty sure we all agree about that.
Every public or private variable IMO should be initialized when the istance is created: the way I prefer is using the class constructor method.
c++ = logic, and so it behaves. I believe that c++ developers try to avoid any logical exception, when possible. :)

Thanks carlorfeo,


I agree with your below comments. We are clear about what is member variable declaration and member variable initialization. But unclear what is about member variable definition.

Could you show us some code about which line of code do you think is member variable definition please? :-)

Quote:

---

Originally Posted by carlorfeo

A class declaration is the abstraction of an object, it's not the object itself.
I'm pretty sure we all agree about that.
Every public or private variable IMO should be initialized when the istance is created: the way I prefer is using the class constructor method.
c++ = logic, and so it behaves. I believe that c++ developers try to avoid any logical exception, when possible. :)

---

regards,
George

Code:

---

Foo fooInstance;

---

This one.

Quote:

---

I think all static variable should be stored to some global storage, maybe the same as where global variables are stored?

---

Yes, but the specific compilation unit matters, too.

Though I don't think that's the actual issue. At least not for static initialization. I think the issue here is simply that by disallowing initialization at the point of declaration, you effectively make it impossible to accidentally give different declarations different values (something that would be possible and nearly undetectable otherwise).
For dynamic initialization, there's also the order of initialization to worry about.

Thanks CornedBee,


1.

Quote:

---

Originally Posted by CornedBee

Code:

---

Foo fooInstance;

---

This one.

---

I have read again the whole post, but I can not find this line of code. I think you mean where is the definition of class instance, right?

But where is the definition of a specific data member variable of a class, like where is the definition of member variable i (not declaration)?

Code:

---

Class Foo {
public:
    int i;
    ...
};

---

Quote:

---

Originally Posted by CornedBee

Though I don't think that's the actual issue. At least not for static initialization. I think the issue here is simply that by disallowing initialization at the point of declaration, you effectively make it impossible to accidentally give different declarations different values (something that would be possible and nearly undetectable otherwise).
For dynamic initialization, there's also the order of initialization to worry about.

---

I do not understand what is "different declarations different values" and "the order of initialization to worry about"? Could you show more description of some pseudo code please?


regards,
George

Quote:

---

Originally Posted by George2

I have read again the whole post, but I can not find this line of code.

---

Correct.

Quote:

---

I think you mean where is the definition of class instance, right?

But where is the definition of a specific data member variable of a class, like where is the definition of member variable i (not declaration)?

---

The member is part of the object, so the definition of the object is the definition of the member. That's what I said here:

Quote:

---

The member is defined as part of the larger object whenever a variable of type Foo is defined.

---

But apparently you really need to be told everything twice.

Quote:

---

I do not understand what is "different declarations different values" and "the order of initialization to worry about"? Could you show more description of some pseudo code please?

---

The order of initialization issue is too complicated for me to come up with a quick example.

The multiple declarations issue occurs when a stupid programmer doesn't refer to the canonical header file for getting a declaration. I'll use normal globals because it's shorter than whole classes, but the issue is the same:

Code:

---

// foo.hpp
extern int GLOBAL = 100;

--------------------------
// foo.cpp
#include "foo.hpp"
int GLOBAL;

--------------------------
// idiot.cpp

// I'm cool, yeah.
extern int GLOBAL = 200;

---

Because the compiler never sees the two declarations at the same time, it can't detect the mismatch. Thus, it's easier to simply forbid initialization at the declaration, of which there can be multiple, and limit it to the definition, of which there can be only one.

Thanks CornedBee,

Quote:

---

Originally Posted by CornedBee

Code:

---

// foo.hpp
extern int GLOBAL = 100;

--------------------------
// foo.cpp
#include "foo.hpp"
int GLOBAL;

--------------------------
// idiot.cpp

// I'm cool, yeah.
extern int GLOBAL = 200;

---

Because the compiler never sees the two declarations at the same time, it can't detect the mismatch. Thus, it's easier to simply forbid initialization at the declaration, of which there can be multiple, and limit it to the definition, of which there can be only one.

---

I am confused what your samples are about,

1. In foo.hpp, you define variable GLOBAL? Not declaration since you initialize there;
2. In foo.cpp, you include foo.hpp, you define GLOBAL and then define another GLOBAL variable, there will be duplicated compile error?
3. In idiot.cpp, you define another GLOBAL variable. The compile can pass.

What is your sample about to say?


regards,
George

The lines that have the extern keyword are declarations. In my example, they contain forbidden initializers. This shows that, if declarations could have initializers, these might differ, without the compiler noticing.

Thanks CornedBee,


1.

Quote:

---

Originally Posted by CornedBee

The lines that have the extern keyword are declarations. In my example, they contain forbidden initializers.

---

I understand this.

2.

Quote:

---

Originally Posted by CornedBee

This shows that, if declarations could have initializers, these might differ, without the compiler noticing.

---

What do you mean differ?


regards,
George

Quote:

---

Originally Posted by George2

What do you mean differ?

---

In one place is

static int = 200;

in the other

static int = 300;

Hi vart,


We are talking about extern, not static right?

Quote:

---

Originally Posted by vart

In one place is

static int = 200;

in the other

static int = 300;

---

regards,
George

Quote:

---

Originally Posted by George2

Hi vart,


We are talking about extern, not static right?




regards,
George

---

I'm talking about static member of the class.
You can have multiple declarations of the same class in different parts of the project.
If you put the initialization of static members inside declaration - you got the problem CornedBee has mentioned

Thanks vart,


My question is answered.

Quote:

---

Originally Posted by vart

I'm talking about static member of the class.
You can have multiple declarations of the same class in different parts of the project.
If you put the initialization of static members inside declaration - you got the problem CornedBee has mentioned

---

regards,
George