Chcę mieć klasę z prywatnym statycznym składnikiem danych (wektorem zawierającym wszystkie znaki az). W Javie lub C # mogę po prostu stworzyć „statyczny konstruktor”, który będzie działał przed utworzeniem jakichkolwiek instancji klasy, i ustawiam statyczne składowe danych klasy. Jest uruchamiany tylko raz (ponieważ zmienne są tylko do odczytu i muszą być ustawione tylko raz), a ponieważ jest to funkcja klasy, ma dostęp do swoich prywatnych członków. Mógłbym dodać kod w konstruktorze, który sprawdza, czy wektor jest zainicjowany, i inicjuje go, jeśli tak nie jest, ale wprowadza to wiele niezbędnych kontroli i nie wydaje się optymalnym rozwiązaniem problemu.

Przychodzi mi do głowy myśl, że skoro zmienne będą tylko do odczytu, mogą być po prostu publicznymi stałymi statycznymi, więc mogę ustawić je raz poza klasą, ale znowu wygląda to na brzydki hack.

Czy można mieć prywatne statyczne elementy członkowskie w klasie, jeśli nie chcę ich inicjować w konstruktorze instancji?

Aby uzyskać odpowiednik konstruktora statycznego, musisz napisać oddzielną zwykłą klasę do przechowywania danych statycznych, a następnie utworzyć statyczną instancję tej zwykłej klasy.

class StaticStuff
{
     std::vector<char> letters_;

public:
     StaticStuff()
     {
         for (char c = 'a'; c <= 'z'; c++)
             letters_.push_back(c);
     }

     // provide some way to get at letters_
};

class Elsewhere
{
    static StaticStuff staticStuff; // constructor runs once, single instance

};

Cóż, możesz mieć

class MyClass
{
    public:
        static vector<char> a;

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

Nie zapomnij (w .cpp) o tym:

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

Program będzie nadal łączył się bez drugiej linii, ale inicjator nie zostanie wykonany.

Rozwiązanie C ++ 11

Od C ++ 11 możesz po prostu użyć wyrażeń lambda do zainicjowania statycznych składowych klas. Działa to nawet wtedy, gdy trzeba narzucić kolejność konstrukcji między różnymi statycznymi elementami lub jeśli masz statyczne elementy, które są const.

Plik nagłówkowy:

class MyClass {
    static const vector<char> letters;
    static const size_t letterCount;
};

Plik źródłowy:

// Initialize MyClass::letters by using a lambda expression.
const vector<char> MyClass::letters = [] {
    vector<char> letters;
    for (char c = 'a'; c <= 'z'; c++)
        letters.push_back(c);
    return letters;
}();

// The initialization order of static members is defined by the order of
// definition within the source file, so we can access MyClass::letters here.
const size_t MyClass::letterCount = letters.size();

W pliku .h:

class MyClass {
private:
    static int myValue;
};

W pliku .cpp:

#include "myclass.h"

int MyClass::myValue = 0;

Oto inne podejście, podobne do Daniela Earwickera, wykorzystujące również sugestię klasy przyjaciela Konrada Rudolpha. Tutaj używamy wewnętrznej klasy użytkowej znajomego prywatnego, aby zainicjować statyczne elementy składowe Twojej głównej klasy. Na przykład:

Plik nagłówkowy:

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;
};

Plik wdrożeniowy:

// 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);
}

To podejście ma tę zaletę, że całkowicie ukrywa klasę Initializer przed światem zewnętrznym, zachowując wszystko zawarte w klasie, która ma zostać zainicjowana.

Test::StaticTest() jest wywoływana dokładnie raz podczas globalnej inicjalizacji statycznej.

Wzywający musi tylko dodać jedną linię do funkcji, która ma być ich konstruktorem statycznym.

static_constructor<&Test::StaticTest>::c;wymusza inicjalizację cpodczas globalnej inicjalizacji statycznej.

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;
}

Nie potrzebujesz init()funkcji, std::vectormożna ją utworzyć z zakresu:

// 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 ) );

Należy jednak pamiętać, że statyka typu klasy powoduje problemy w bibliotekach, dlatego należy ich tam unikać.

Aktualizacja C ++ 11

Począwszy od C ++ 11, możesz to zrobić zamiast tego:

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

Jest semantycznie równoważne z rozwiązaniem C ++ 98 w oryginalnej odpowiedzi, ale nie można użyć literału ciągu po prawej stronie, więc nie jest całkowicie lepszy. Jednakże, jeśli masz wektor innego rodzaju niż char, wchar_t, char16_tlub char32_t(tablice, z których może być zapisany jako napisowych), wersja C ++ 11 będzie bezwzględnie usunąć kod szablonowe bez wprowadzania innej składni, w porównaniu do C ++ 98 wersja.

Pojęcie konstruktorów statycznych zostało wprowadzone w Javie po zapoznaniu się z problemami w C ++. Nie mamy więc bezpośredniego odpowiednika.

Najlepszym rozwiązaniem jest użycie typów POD, które można jawnie zainicjować.
Lub nadaj statycznym elementom członkowskim określony typ, który ma własny konstruktor, który zainicjuje go poprawnie.

//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;

Próbując skompilować i użyć klasy Elsewhere(z odpowiedzi Earwickera ) otrzymuję:

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

Wydaje się, że nie jest możliwe zainicjowanie statycznych atrybutów typów innych niż całkowite bez umieszczenia kodu poza definicją klasy (CPP).

Aby dokonać tej kompilacji, możesz zamiast tego użyć „ metody statycznej ze statyczną zmienną lokalną wewnątrz ”. Coś takiego:

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

Możesz również przekazać argumenty do konstruktora lub zainicjować go określonymi wartościami, jest bardzo elastyczny, wydajny i łatwy do zaimplementowania ... jedyną rzeczą jest to, że masz metodę statyczną zawierającą zmienną statyczną, a nie atrybut statyczny ... składnia zmienia się nieco, ale nadal jest przydatna. Mam nadzieję, że komuś się to przyda,

Hugo González Castro.

Myślę, że prostym rozwiązaniem będzie:

    //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;
    }

Właśnie rozwiązałem tę samą sztuczkę. Musiałem określić definicję pojedynczego statycznego elementu członkowskiego dla Singletona. Ale komplikuj sprawę - zdecydowałem, że nie chcę wywoływać ctora RandClass (), chyba że go użyję ... dlatego nie chciałem inicjalizować singletona globalnie w swoim kodzie. Dodałem też prosty interfejs w moim przypadku.

Oto ostateczny kod:

Uprościłem kod i użyłem funkcji rand () i jej pojedynczego ziarna 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();
}

Oto mój wariant rozwiązania EFraim; różnica polega na tym, że dzięki niejawnej instancji szablonu konstruktor statyczny jest wywoływany tylko wtedy, gdy tworzone są instancje klasy i nie .cppjest potrzebna żadna definicja w pliku (dzięki magii tworzenia instancji szablonu).

W .hpliku masz:

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;

W .cpppliku możesz mieć:

void foobar() {
    MyClass foo; // [1]

    for (vector<char>::iterator it = MyClass::a.begin(); it < MyClass::a.end(); ++it) {
        cout << *it;
    }
    cout << endl;
}

Zauważ, że MyClass::ajest inicjowane tylko wtedy, gdy istnieje linia [1], ponieważ wywołuje (i wymaga utworzenia instancji) konstruktora, który następnie wymaga instancji _initializer.

Oto inna metoda, w której wektor jest prywatny dla pliku zawierającego implementację przy użyciu anonimowej przestrzeni nazw. Jest to przydatne w przypadku takich rzeczy, jak tabele wyszukiwania, które są prywatne dla implementacji:

#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;
}

Z pewnością nie musi być tak skomplikowane, jak obecnie akceptowana odpowiedź (autorstwa Daniela Earwickera). Klasa jest zbędna. W tym przypadku nie ma potrzeby wojny językowej.

plik .hpp:

vector<char> const & letters();

plik .cpp:

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

Oferty GCC

__attribute__((constructor))

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

Oznacz metodę statyczną tym atrybutem, a będzie ona działać przy ładowaniu modułu, przed funkcją main ().

Definiujesz statyczne zmienne składowe podobnie do sposobu definiowania metod składowych.

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;

Aby zainicjować zmienną statyczną, wystarczy zrobić to wewnątrz pliku źródłowego. Na przykład:

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


//Foo.cpp
int Foo::hello = 1;

Co powiesz na utworzenie szablonu naśladującego zachowanie języka 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
    };
};

W prostych przypadkach, takich jak tutaj, zmienna statyczna opakowana wewnątrz statycznej funkcji składowej jest prawie tak dobra. Jest to proste i zazwyczaj zostanie zoptymalizowane przez kompilatory. Nie rozwiązuje to jednak problemu kolejności inicjalizacji dla złożonych obiektów.

#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();
}

Czy to jest rozwiązanie?

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

Konstruktor statyczny można emulować przy użyciu klasy zaprzyjaźnionej lub klasy zagnieżdżonej, jak poniżej.

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();
}

Wynik:

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

Wow, nie mogę uwierzyć, że nikt nie wspomniał o najbardziej oczywistej odpowiedzi, która najbardziej naśladuje zachowanie statycznego konstruktora C #, tj. Nie jest wywoływana, dopóki nie zostanie utworzony pierwszy obiekt tego typu.

std::call_once()jest dostępny w C ++ 11; jeśli nie możesz tego użyć, możesz to zrobić za pomocą statycznej zmiennej typu boolean oraz operacji atomowej typu „porównaj i zamień”. Sprawdź w swoim konstruktorze, czy możesz atomowo zmienić flagę statyczną klasy z falsena true, a jeśli tak, możesz uruchomić kod konstrukcji statycznej.

Aby uzyskać dodatkowe punkty, utwórz flagę trójstronną zamiast wartości logicznej, tj. Nie uruchomiono, uruchomiono i zakończono uruchamianie. Następnie wszystkie inne instancje tej klasy mogą się blokować, dopóki instancja, na której działa konstruktor statyczny, nie zakończy się (tj. Wystawi ochronę pamięci, a następnie ustaw stan na „gotowe do działania”). Twój spin-lock powinien wykonywać instrukcję "pauza" procesora, podwajać czas oczekiwania aż do progu itd. - całkiem standardowa technika blokowania obrotów.

W przypadku braku C ++ 11 to powinno Ci zacząć.

Oto pseudokod, który Cię poprowadzi. Umieść to w definicji swojej klasy:

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

A to w twoim konstruktorze:

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();