How do you initialize static data members, similar to static constructors? [duplicate]

Well you can have

class MyClass { public: static vector<char> a; static class _init { public: _init() { for(char i='a'; i<='z'; i++) a.push_back(i); } } _initializer; }; 

Don't forget (in the .cpp) this:

vector<char> MyClass::a; MyClass::_init MyClass::_initializer; 

The program will still link without the second line, but the initializer will not be executed.

C++17

Since C++17, you can initialize complex static data members by using lambda expressions and declaring them inline:

class MyClass { inline static const std::vector<char> letters = [] { std::vector<char> letters; for (char c = 'a'; c <= 'z'; c++) letters.push_back(c); return letters; }(); }; 

C++11

Since C++11, you can initialize complex static data members by using lambda expressions:

Header file:

class MyClass { static const std::vector<char> letters; }; 

Source file:

const std::vector<char> MyClass::letters = [] { std::vector<char> letters; for (char c = 'a'; c <= 'z'; c++) letters.push_back(c); return letters; }(); 

In the .h file:

class MyClass { private: static int myValue; }; 

In the .cpp file:

#include "myclass.h" int MyClass::myValue = 0; 

Here is another approach similar to Daniel Earwicker's, also using Konrad Rudolph's friend class suggestion. Here we use an inner private friend utility class to initialize the static members of your main class. For example:

Header file:

class ToBeInitialized { // Inner friend utility class to initialize whatever you need class Initializer { public: Initializer(); }; friend class Initializer; // Static member variables of ToBeInitialized class static const int numberOfFloats; static float *theFloats; // Static instance of Initializer // When this is created, its constructor initializes // the ToBeInitialized class' static variables static Initializer initializer; }; 

Implementation file:

// Normal static scalar initializer const int ToBeInitialized::numberOfFloats = 17; // Constructor of Initializer class. // Here is where you can initialize any static members // of the enclosing ToBeInitialized class since this inner // class is a friend of it. ToBeInitialized::Initializer::Initializer() { ToBeInitialized::theFloats = (float *)malloc(ToBeInitialized::numberOfFloats * sizeof(float)); for (int i = 0; i < ToBeInitialized::numberOfFloats; ++i) ToBeInitialized::theFloats[i] = calculateSomeFancyValue(i); } 

This approach has the advantage of completely hiding the Initializer class from the outside world, keeping everything contained within the class to be initialized.

Test::StaticTest() is called exactly once during global static initialization.

Caller only has to add one line to the function that is to be their static constructor.

static_constructor<&Test::StaticTest>::c; forces initialization of c during global static initialization.

template<void(*ctor)()> struct static_constructor { struct constructor { constructor() { ctor(); } }; static constructor c; }; template<void(*ctor)()> typename static_constructor<ctor>::constructor static_constructor<ctor>::c; ///////////////////////////// struct Test { static int number; static void StaticTest() { static_constructor<&Test::StaticTest>::c; number = 123; cout << "static ctor" << endl; } }; int Test::number; int main(int argc, char *argv[]) { cout << Test::number << endl; return 0; } 

No need for an init() function, std::vector can be created from a range:

// h file: class MyClass { static std::vector<char> alphabet; // ... }; // cpp file: #include <boost/range.hpp> static const char alphabet[] = "abcdefghijklmnopqrstuvwxyz"; std::vector<char> MyClass::alphabet( boost::begin( ::alphabet ), boost::end( ::alphabet ) ); 

Note, however, that statics of class type cause trouble in libraries, so they should be avoided there.

C++11 Update

As of C++11, you can do this instead:

// cpp file: std::vector<char> MyClass::alphabet = { 'a', 'b', 'c', ..., 'z' }; 

It's semantically equivalent to the C++98 solution in the original answer, but you can't use a string literal on the right-hand-side, so it's not completely superior. However, if you have a vector of any other type than char, wchar_t, char16_t or char32_t (arrays of which can be written as string literals), the C++11 version will strictly remove boilerplate code without introducing other syntax, compared to the C++98 version.

The concept of static constructors was introduced in Java after they learned from the problems in C++. So we have no direct equivalent.

The best solution is to use POD types that can be initialised explicitly.
Or make your static members a specific type that has its own constructor that will initialize it correctly.

//header class A { // Make sure this is private so that nobody can missues the fact that // you are overriding std::vector. Just doing it here as a quicky example // don't take it as a recomendation for deriving from vector. class MyInitedVar: public std::vector<char> { public: MyInitedVar() { // Pre-Initialize the vector. for(char c = 'a';c <= 'z';++c) { push_back(c); } } }; static int count; static MyInitedVar var1; }; //source int A::count = 0; A::MyInitedVar A::var1; 

When trying to compile and use class Elsewhere (from Earwicker's answer) I get:

error LNK2001: unresolved external symbol "private: static class StaticStuff Elsewhere::staticStuff" (?staticStuff@Elsewhere@@0VStaticStuff@@A) 

It seems is not possible to initialize static attributes of non-integer types without putting some code outside the class definition (CPP).

To make that compile you can use "a static method with a static local variable inside" instead. Something like this:

class Elsewhere { public: static StaticStuff& GetStaticStuff() { static StaticStuff staticStuff; // constructor runs once, single instance return staticStuff; } }; 

And you may also pass arguments to the constructor or initialize it with specific values, it is very flexible, powerfull and easy to implement... the only thing is you have a static method containing a static variable, not a static attribute... syntaxis changes a bit, but still useful. Hope this is useful for someone,

Hugo González Castro.

I guess Simple solution to this will be:

 //X.h #pragma once class X { public: X(void); ~X(void); private: static bool IsInit; static bool Init(); }; //X.cpp #include "X.h" #include <iostream> X::X(void) { } X::~X(void) { } bool X::IsInit(Init()); bool X::Init() { std::cout<< "ddddd"; return true; } // main.cpp #include "X.h" int main () { return 0; } 

Wow, I can't believe no one mentioned the most obvious answer, and one that most closely mimics C#'s static-constructor behavior, i.e. it doesn't get called until the first object of that type is created.

std::call_once() is available in C++11; if you can't use that, it can be done with a static boolean class-variable, and a compare-and-exchange atomic-operation. In your constructor, see if you can atomically change the class-static flag from false to true, and if so, you can run the static-construction code.

For extra credit, make it a 3-way flag instead of a boolean, i.e. not run, running, and done running. Then all other instances of that class can spin-lock until the instance running the static-constructor has finished (i.e. issue a memory-fence, then set the state to "done running"). Your spin-lock should execute the processor's "pause" instruction, double the wait each time up until a threshold, etc. — pretty standard spin-locking technique.

In the absence of C++11, this should get you started.

Here's some pseudocode to guide you. Put this in your class definition:

enum EStaticConstructor { kNotRun, kRunning, kDone }; static volatile EStaticConstructor sm_eClass = kNotRun; 

And this in your constructor:

while (sm_eClass == kNotRun) { if (atomic_compare_exchange_weak(&sm_eClass, kNotRun, kRunning)) { /* Perform static initialization here. */ atomic_thread_fence(memory_order_release); sm_eClass = kDone; } } while (sm_eClass != kDone) atomic_pause(); 

Just solved same trick. I had to specify definition of a single static member for Singleton. But make things more complicated - I have decided that I do not want to call ctor of RandClass() unless I am gonna use it... that is why I did not want to initialize singleton globally in my code. Also I've added simple interface in my case.

Here is the final code:

I simplified code and use rand() function and its single seed initialzer srand()

interface IRandClass { public: virtual int GetRandom() = 0; }; class RandClassSingleton { private: class RandClass : public IRandClass { public: RandClass() { srand(GetTickCount()); }; virtual int GetRandom(){return rand();}; }; RandClassSingleton(){}; RandClassSingleton(const RandClassSingleton&); // static RandClass m_Instance; // If you declare m_Instance here you need to place // definition for this static object somewhere in your cpp code as // RandClassSingleton::RandClass RandClassSingleton::m_Instance; public: static RandClass& GetInstance() { // Much better to instantiate m_Instance here (inside of static function). // Instantiated only if this function is called. static RandClass m_Instance; return m_Instance; }; }; main() { // Late binding. Calling RandClass ctor only now IRandClass *p = &RandClassSingleton::GetInstance(); int randValue = p->GetRandom(); } abc() { IRandClass *same_p = &RandClassSingleton::GetInstance(); } 

Here's my variant of EFraim's solution; the difference is that, thanks to implicit template instantiation, the static constructor is only called if instances of the class are created, and that no definition in the .cpp file is needed (thanks to template instantiation magic).

In the .h file, you have:

template <typename Aux> class _MyClass { public: static vector<char> a; _MyClass() { (void) _initializer; //Reference the static member to ensure that it is instantiated and its initializer is called. } private: static struct _init { _init() { for(char i='a'; i<='z'; i++) a.push_back(i); } } _initializer; }; typedef _MyClass<void> MyClass; template <typename Aux> vector<char> _MyClass<Aux>::a; template <typename Aux> typename _MyClass<Aux>::_init _MyClass<Aux>::_initializer; 

In the .cpp file, you can have:

void foobar() { MyClass foo; // [1] for (vector<char>::iterator it = MyClass::a.begin(); it < MyClass::a.end(); ++it) { cout << *it; } cout << endl; } 

Note that MyClass::a is initialized only if line [1] is there, because that calls (and requires instantiation of) the constructor, which then requires instantiation of _initializer.

Here's another method, where the vector is private to the file that contains the implementation by using an anonymous namespace. It's useful for things like lookup tables that are private to the implementation:

#include <iostream> #include <vector> using namespace std; namespace { vector<int> vec; struct I { I() { vec.push_back(1); vec.push_back(3); vec.push_back(5); }} i; } int main() { vector<int>::const_iterator end = vec.end(); for (vector<int>::const_iterator i = vec.begin(); i != end; ++i) { cout << *i << endl; } return 0; } 

It certainly doesn't need to be as complicated as the currently accepted answer (by Daniel Earwicker). The class is superfluous. There's no need for a language war in this case.

.hpp file:

vector<char> const & letters(); 

.cpp file:

vector<char> const & letters() { static vector<char> v = {'a', 'b', 'c', ...}; return v; } 

GCC offers

__attribute__((constructor)) 

https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html

Tag a static method with this attribute and it will run on module load, before main().

You define static member variables similarly to the way you define member methods.

foo.h

class Foo { public: void bar(); private: static int count; }; 

foo.cpp

#include "foo.h" void Foo::bar() { // method definition } int Foo::count = 0; 

To initialize a static variable, you just do so inside of a source file. For example:

//Foo.h class Foo { private: static int hello; }; //Foo.cpp int Foo::hello = 1; 

How about creating a template to mimic the behavior of C#.

template<class T> class StaticConstructor { bool m_StaticsInitialised = false; public: typedef void (*StaticCallback)(void); StaticConstructor(StaticCallback callback) { if (m_StaticsInitialised) return; callback(); m_StaticsInitialised = true; } } template<class T> bool StaticConstructor<T>::m_StaticsInitialised; class Test : public StaticConstructor<Test> { static std::vector<char> letters_; static void _Test() { for (char c = 'a'; c <= 'z'; c++) letters_.push_back(c); } public: Test() : StaticConstructor<Test>(&_Test) { // non static stuff }; }; 

For simple cases like here a static variable wrapped inside a static member function is nearly as good. It's simple and will usually be optimized away by compilers. This does not solve initialization order problem for complex objects though.

#include <iostream> class MyClass { static const char * const letters(void){ static const char * const var = "abcdefghijklmnopqrstuvwxyz"; return var; } public: void show(){ std::cout << letters() << "\n"; } }; int main(){ MyClass c; c.show(); } 

Is this a solution?

class Foo { public: size_t count; Foo() { static size_t count = 0; this->count = count += 1; } }; 

A static constructor can be emulated by using a friend class or nested class as below.

class ClassStatic{ private: static char *str; public: char* get_str() { return str; } void set_str(char *s) { str = s; } // A nested class, which used as static constructor static class ClassInit{ public: ClassInit(int size){ // Static constructor definition str = new char[size]; str = "How are you?"; } } initializer; }; // Static variable creation char* ClassStatic::str; // Static constructor call ClassStatic::ClassInit ClassStatic::initializer(20); int main() { ClassStatic a; ClassStatic b; std::cout << "String in a: " << a.get_str() << std::endl; std::cout << "String in b: " << b.get_str() << std::endl; a.set_str("I am fine"); std::cout << "String in a: " << a.get_str() << std::endl; std::cout << "String in b: " << b.get_str() << std::endl; std::cin.ignore(); } 

Output:

String in a: How are you? String in b: How are you? String in a: I am fine String in b: I am fine 

I use this technique to init static stuff : In the .cpp file :

struct InitMe { InitMe(){ // do all the static stuff you want here } } initMe; 

Because it's in a compilation unit, the variable initMe will have a program lifetime. The constructor will be initialized before main(), and the destructor, if any, will be called before program termination. Like all static stuff, there's no guarantee on the order it will be executed, but in a single .cpp file, there's a guarantee that static stuff will be initialized in order they appear in the file.