static constructors in C I need to initialize private static objects

Question

I want to have a class with a private static data member  a vector that contains all the characters a-z   In java or C   I can just make a  static constructor  that will run before I make any instances of the class  and sets up the static data members of the class  It only gets run once  as the variables are read only and only need to be set once  and since it s a function of the class it can access its private members  I could add code in the constructor that checks to see if the vector is initialized  and initialize it if it s not  but that introduces many necessary checks and doesn t seem like the optimal solution to the problem   The thought occurs to me that since the variables will be read only  they can just be public static const  so I can set them once outside the class  but once again  it seems sort of like an ugly hack    Is it possible to have private static data members in a class if I don t want to initialize them in the instance constructor

User · Answer

Well you can have  class MyClass       public          static vector lt char gt  a           static class  init                     public               init     for char i  a   i lt   z   i    a push back i                initializer       Don t forget  in the  cpp  this   vector lt char gt  MyClass  a  MyClass   init MyClass   initializer    The program will still link without the second line  but the initializer will not be executed

User · Answer

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  lt iostream gt   include  lt vector gt  using namespace std   namespace     vector lt int gt  vec     struct I   I         vec push back 1       vec push back 3       vec push back 5        i     int main        vector lt int gt   const iterator end   vec end      for  vector lt int gt   const iterator i   vec begin           i    end    i        cout  lt  lt   i  lt  lt  endl         return 0

User · Answer

How about creating a template to mimic the behavior of C    template lt class T gt  class StaticConstructor       bool m StaticsInitialised   false   public      typedef void   StaticCallback  void        StaticConstructor StaticCallback callback                if  m StaticsInitialised              return           callback             m StaticsInitialised   true           template lt class T gt  bool StaticConstructor lt T gt   m StaticsInitialised   class Test   public StaticConstructor lt Test gt        static std  vector lt char gt  letters        static void  Test                 for  char c    a   c  lt    z   c                letters  push back c          public      Test     StaticConstructor lt Test gt   amp  Test                   non static stuff

User · Answer

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

User · Answer

Is this a solution   class Foo   public      size t count      Foo                 static size t count   0          this- gt count   count    1

User · Answer

To get the equivalent of a static constructor  you need to write a separate ordinary class to hold the static data and then make a static instance of that ordinary class   class StaticStuff        std  vector lt char gt  letters    public       StaticStuff                   for  char c    a   c  lt    z   c                 letters  push back c                   provide some way to get at letters      class Elsewhere       static StaticStuff staticStuff     constructor runs once  single instance

User · Answer

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 lt char gt                public          MyInitedVar                           Pre-Initialize the vector             for char c    a  c  lt    z    c                              push back c                                     static int          count      static MyInitedVar  var1          source int            A  count   0  A  MyInitedVar A  var1

User · Answer

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  lt typename Aux gt  class  MyClass       public          static vector lt char gt  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 lt   z   i    a push back i                initializer      typedef  MyClass lt void gt  MyClass   template  lt typename Aux gt  vector lt char gt   MyClass lt Aux gt   a  template  lt typename Aux gt  typename  MyClass lt Aux gt    init  MyClass lt Aux gt    initializer    In the  cpp file  you can have   void foobar         MyClass foo      1       for  vector lt char gt   iterator it   MyClass  a begin    it  lt  MyClass  a end      it            cout  lt  lt   it            cout  lt  lt  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

User · Answer

No need for an init   function  std  vector can be created from a range      h file  class MyClass       static std  vector lt char gt  alphabet                cpp file   include  lt boost range hpp gt  static const char alphabet      abcdefghijklmnopqrstuvwxyz   std  vector lt char gt  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 lt char gt  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

User · Answer

In the  h file   class MyClass   private      static int myValue       In the  cpp file    include  myclass h   int MyClass  myValue   0

User · Answer

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  lt iostream gt   class MyClass         static const char   const letters void           static const char   const var    abcdefghijklmnopqrstuvwxyz           return var             public          void show                std  cout  lt  lt  letters    lt  lt    n                  int main        MyClass c      c show

User · Answer

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  lt  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

User · Answer

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

User · Answer

C  11 solution Since C  11  you can simply use lambda expressions to initialize static class members  This even works with const static members as well  You can also impose an order of construction between multiple static class members  since static members are always initialized in the order as defined within the source file  Header file  class MyClass       static const vector lt char gt  letters      Source file  const vector lt char gt  MyClass  letters            vector lt char gt  letters      for  char c    a   c  lt    z   c            letters push back c       return letters

User · Answer

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 amp          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 amp  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    amp RandClassSingleton  GetInstance        int randValue   p- gt GetRandom      abc         IRandClass  same p    amp RandClassSingleton  GetInstance

User · Answer

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 lt  amp Test  StaticTest gt   c  forces initialization of c during global static initialization   template lt void  ctor    gt  struct static constructor       struct constructor   constructor     ctor             static constructor c      template lt void  ctor    gt  typename static constructor lt ctor gt   constructor static constructor lt ctor gt   c                                  struct Test       static int number       static void StaticTest                 static constructor lt  amp Test  StaticTest gt   c           number   123          cout  lt  lt   static ctor   lt  lt  endl            int Test  number   int main int argc  char  argv          cout  lt  lt  Test  number  lt  lt  endl      return 0

User · Answer

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

User · Answer

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 amp  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

User · Answer

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  lt iostream gt       X  X void                    X   X void                   bool X  IsInit Init         bool X  Init                     std  cout lt  lt   ddddd               return true                main cpp      include  X h      int main                      return 0

User · Answer

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 lt char gt  const  amp  letters       cpp file   vector lt char gt  const  amp  letters       static vector lt char gt  v     a    b    c           return v

User · Answer

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   mdash  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  amp sm eClass  kNotRun  kRunning                    Perform static initialization here              atomic thread fence memory order release           sm eClass   kDone          while  sm eClass    kDone      atomic pause

User · Answer

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  lt  lt   String in a     lt  lt  a get str    lt  lt  std  endl      std  cout  lt  lt   String in b     lt  lt  b get str    lt  lt  std  endl      a set str  I am fine        std  cout  lt  lt   String in a     lt  lt  a get str    lt  lt  std  endl      std  cout  lt  lt   String in b     lt  lt  b get str    lt  lt  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

[c++] static constructors in C++? I need to initialize private static objects

Examples related to c++

Examples related to static

Examples related to private

Examples related to initializer

Examples related to static-constructor