Question: I've got a strange problem with a static variable that is obviously not initialized as it should be.

I have a huge project that runs with Windows and Linux. As the Linux developer doesn't have this problem I would suggest that this is some kind of wired Visual Studio stuff.

Header file

```
class MyClass
{
    // some other stuff here
    ...
    private:
        static AnotherClass* const Default_;
};

```

CPP file

```
AnotherClass* const MyClass::Default_(new AnotherClass(""));
MyClass(AnotherClass* const var)
{
    assert(Default_);
    ...
}

```

Problem is that `Default_`is always `NULL`. I also tried a breakpoint at the initialization of that variable but I cannot catch it.

There is a similar problem in another class.

CPP file

```
std::string const MyClass::MyString_ ("someText");
MyClass::MyClass()
{
    assert(MyString_ != "");
    ...
}

```

In this case `MyString_`is always empty. So again not initialized.

Does anyone have an idea about that? Is this a Visual Studio settings problem?

Cheers Simon

**Edit:**

I also came across the static initialization fiasco. But I'm not sure if that could be the problem because there are no problems with the Linux compiler. Shouldn't the compiler react the same way in this case?

Answer: 
> 
> Shouldn't the compiler react the same way in this case?
> 
> 
> 

No. As I understand it, the initialization order of individual compilation units is UNDEFINED. So the Linux developer just got lucky. Today. Tomorrow, who knows?
Works On My Machine(TM): 

```
#include <iostream>
#include <cassert>

class AnotherClass
{
public:
    AnotherClass(const char*) {}
};

class MyClass
{
public:
    MyClass(AnotherClass* const var);
private:
    static AnotherClass* const Default_;
};

AnotherClass* const MyClass::Default_(new AnotherClass(""));

MyClass::MyClass(AnotherClass* const var)
{
    assert(Default_);
    std::cout << "Worked!\n";
}

int main()
{
    MyClass tester(NULL);
    return 0;
}

```

I suppose the problem is that `MyClass::MyClass()` is called as another static variable's constructor. The initialization of static variables doesn't always occur in the order you would like it to.