Static object doesn't call its constructor?

[Pyrius]

I'm resizing a std::vector in the constructor of a class, and when I later try to access it the std::vector is empty. The following code reproduces the problem:

#include <iostream>
#include <vector>

class Foo
{
public:

    Foo();

    static void Bar();

private:

    static Foo foo;

    static std::vector <short> shorts;
};

std::vector <short> Foo::shorts;

Foo::Foo()
{
    shorts.resize(5, 0);
}

void Foo::Bar()
{
    std::cout << shorts.size();
}

int main()
{
    Foo::Bar();
}

However, when creating the Foo object in the int main() function, the std::vector is resized. Does this mean the constructor of a static object doesn't get called on creation?

Any help would be appreciated, thanks.

EDIT: I've experimented and found out that the constructor doesn't get called. Does anyone know why this is?

[Athar]

You aren't creating a Foo object in main(), you're just calling Bar().

[Pyrius]

Oh, so member objects' constructors don't get called?

[Athar]

Huh? The constructor is called when you create a Foo object, which you aren't doing. You're calling Bar without an object, which is only possible because it's a static member function.
As for static members, they're created when the program starts, which also means their constructor is called (vector<short>'s default constructor in this case).

[Pyrius]

When I said "when creating the Foo object in the int main() function, the std::vector is resized," I meant that if I were to create the Foo object in int main() instead of the class Foo, the std::vector would be resized. I was wondering why the Foo object's constructor wasn't being called. How would I call a member object's constructor, if possible?

[ciphermagi]

What Athar is trying to say is what I said to someone earlier. Classes are variables. You treat them just like any other variable.

Example:

int main(){
    int a, b; // Declare the variables a and b
    a = 1; // Define the variable a
    b = 1; // Define the variable b

    a += b; // Operate on the variables a and b
}

Now with classes:

class Foo{
    static Foo foo;
    static std::vector<short> shorts;

public:
    Foo();
    static void Bar();
};

std::vector<short> Foo::shorts;

Foo::Foo(){
    shorts.resize(5, 0);
}

void Foo::Bar(){
    std::cout << shorts.size();
}

int main(){
    Foo foos; // Declare a variable
    foos = new Foo; // Define a variable

    Foo::Bar(); // Operate on a variable
    delete foos; // Undefine a variable
    return 0;
}

[Pyrius]

I understand that objects are variables, but why don't their constructors get called if they're declared in a class and not in int main() or in a function int main() calls?

[ciphermagi]

They do, but you never declared an instance of the object. You have to actually go through the process of creating an instance of the object that you're attempting to manipulate, and in your example you aren't doing that. Look at my examples, specifically the comments that I put in, and compare the two examples.

[Pyrius]

"foo" isn't an instance of Foo? Both examples have a line which declares an instance of the object, don't they? "static Foo foo" and "Foo foos" aren't both declarations?

[Disch]

There are 2 constructors in question here:

1) Foo's constructor
2) std::vector's constructor (for your 'shorts' vector)

The #2 constructor is being called once before main starts. This constructor initializes the vector to have zero elements. This can be shown by your Bar() function which undoubtedly prints 0.

The #2 constructor is called because you are creating a vector object. That object is called 'shorts'.

The #1 constructor is never being called in this program because you are not actually creating any Foo objects. You almost are, but you don't. You have a static Foo object in the Foo class, but you never instantiate it, so it is never actually created.

If you want that Foo to be instantiated, you need to add this line:

class Foo
{ /* ... */ };

std::vector <short> Foo::shorts;  // instantiates Foo::shorts
Foo Foo::foo;  // instantiates Foo::foo  (calls Foo's ctor) 

[Athar]

Ah, I saw only now that you actually had a static Foo object.
However, it's just a declaration, not a definition. You still need to instantiate it as you did with the vector.
Edit: ninja'ed.

And unless you want the vector to be resized every time a Foo instance is created, you should initialize the vector as needed initially:
std::vector<short> Foo::shorts(5);

[ciphermagi]

Pyrius, think about what you're asking.

"static Foo foo" and "Foo foos" aren't both declarations?

My declaration was inside of int main. Your declaration was inside of the class object. You're basically trying to hatch an egg that doesn't have a chicken to hatch from yet.

[Pyrius]

Oh... okay, thanks for explaining.

EDIT: Now the constructor is being called, but later on when I call shorts it has a size of 0.

#include <iostream>
#include <vector>

class Foo
{
public:

    Foo();

    static Foo foo;

    static std::vector <short> shorts;
};

Foo Foo::foo;

std::vector <short> Foo::shorts;

Foo::Foo()
{
    shorts.resize(5, 3);
    std::cout << "shorts is of size " << shorts.size() << ".\n\n";
}

int main()
{
    std::cout << "shorts is of size " << Foo::shorts.size() << ".\n";
}

This outputs first "shorts is of size 5," and then "shorts is of size 0"

[Disch]

Static initialization order fiasco.

'shorts' is being constructed AFTER 'foo' is, so first, foo is resizing a vector that has not been constructed yet (!!! very bad!!!), then shorts's constructor initializes it to a size of 0

This results in (at best) a memory leak, but also could corrupt the heap.

This is one reason why statics/globals are a bad idea and should be avoided.

[Pyrius]

Ah, okay. I can definitely see how resizing a vector before constructing it could be bad :), thanks.

[m4ster r0shi]

Technically this is not 'static initialization order fiasco'. That only applies when your globals are scattered among several compilation units. In this case putting Foo::shorts above Foo::foo would do the trick (I'm not sure, but I think the standard guarantees that inside a compilation unit globals are initialized in the order they are defined). But yes, it's a good idea to avoid statics and globals in general, and it's good to know about the 'static initialization order fiasco' -> http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.14