개인 정적 데이터 멤버 (모든 문자 az를 포함하는 벡터)가있는 클래스를 갖고 싶습니다. Java 또는 C #에서는 클래스의 인스턴스를 만들기 전에 실행될 "정적 생성자"를 만들고 클래스의 정적 데이터 멤버를 설정할 수 있습니다. 변수는 읽기 전용이고 한 번만 설정하면되므로 한 번만 실행되며 클래스의 함수이므로 개인 멤버에 액세스 할 수 있습니다. 벡터가 초기화되었는지 확인하고 그렇지 않은 경우 초기화하는 코드를 생성자에 추가 할 수 있지만 필요한 검사가 많이 발생하고 문제에 대한 최적의 솔루션처럼 보이지 않습니다.

변수는 읽기 전용이기 때문에 공개 정적 const 일 수 있으므로 클래스 외부에서 한 번 설정할 수 있지만 다시 한 번 추한 해킹처럼 보입니다.

인스턴스 생성자에서 초기화하지 않으려는 경우 클래스에 개인 정적 데이터 멤버를 가질 수 있습니까?

정적 생성자와 동등한 것을 얻으려면 정적 데이터를 보유하기 위해 별도의 일반 클래스를 작성한 다음 해당 일반 클래스의 정적 인스턴스를 만들어야합니다.

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

};

당신은 할 수 있습니다

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

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

.cpp에서 이것을 잊지 마십시오.

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

프로그램은 여전히 ​​두 번째 줄없이 연결되지만 초기화 프로그램은 실행되지 않습니다.

C ++ 11 솔루션

C ++ 11부터는 람다 식 을 사용 하여 정적 클래스 멤버를 초기화 할 수 있습니다 . 이것은 다양한 정적 멤버 사이에 구성 순서를 적용해야하거나 정적 멤버가 인 경우에도 작동합니다 const.

헤더 파일 :

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

소스 파일:

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

.h 파일에서 :

class MyClass {
private:
    static int myValue;
};

.cpp 파일에서 :

#include "myclass.h"

int MyClass::myValue = 0;

다음은 Konrad Rudolph의 친구 클래스 제안을 사용하여 Daniel Earwicker와 유사한 또 다른 접근법입니다. 여기서는 내부 개인 친구 유틸리티 클래스를 사용하여 기본 클래스의 정적 멤버를 초기화합니다. 예를 들면 다음과 같습니다.

헤더 파일 :

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

구현 파일 :

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

이 접근 방식은 Initializer 클래스를 외부 세계에서 완전히 숨기고 클래스에 포함 된 모든 항목을 초기화하는 이점이 있습니다.

Test::StaticTest() 전역 정적 초기화 중에 정확히 한 번 호출됩니다.

호출자는 정적 생성자가 될 함수에 한 줄만 추가하면됩니다.

static_constructor<&Test::StaticTest>::c;c전역 정적 초기화 중 초기화를 강제합니다 .

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

init()기능이 필요하지 않으며 std::vector범위에서 만들 수 있습니다.

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

그러나 클래스 유형의 정적 요소는 라이브러리에서 문제를 일으키므로 피해야합니다.

C ++ 11 업데이트

C ++ 11부터는 다음과 같이 할 수 있습니다.

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

원래 답변의 C ++ 98 솔루션과 의미 상 동일하지만 오른쪽에 문자열 리터럴을 사용할 수 없으므로 완전히 우수하지는 않습니다. 당신이 다른 유형의 벡터이있는 경우 그러나,보다 char, wchar_t, char16_t또는 char32_t(문자열 리터럴로 기록 될 수있는 배열), 엄격하게 다른 구문을 도입하지 않고 상용구 코드를 제거합니다 C ++ 11 버전은 C ++ 98에 비해 버전.

정적 생성자 개념은 C ++의 문제점을 알게 된 후 Java로 도입되었습니다. 따라서 우리는 직접적으로 동등한 것이 없습니다.

가장 좋은 해결책은 명시 적으로 초기화 할 수있는 POD 유형을 사용하는 것입니다.
또는 정적 멤버를 올바르게 초기화하는 자체 생성자가있는 특정 유형으로 만드십시오.

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

컴파일하고 클래스를 사용 하려고 할 때 Elsewhere( Earwicker의 답변에서 ) 다음을 얻습니다.

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

CPP (클래스 정의) 외부에 일부 코드를 넣지 않으면 정수가 아닌 유형의 정적 속성을 초기화 할 수 없습니다.

컴파일하려면 " 내부에 정적 로컬 변수가있는 정적 메소드 "를 대신 사용할 수 있습니다. 이 같은:

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

또한 생성자에 인수를 전달하거나 특정 값으로 초기화 할 수 있습니다. 매우 유연하고 강력하며 구현하기 쉽습니다 ... 유일한 것은 정적 속성이 아닌 정적 변수를 포함하는 정적 메서드가 있다는 것입니다. 구문은 약간 변경되지만 여전히 유용합니다. 이것이 누군가에게 유용하기를 바랍니다.

휴고 곤잘레스 카스트로

이것에 대한 간단한 해결책은 다음과 같습니다.

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

같은 속임수를 해결했습니다. Singleton에 대한 단일 정적 멤버의 정의를 지정해야했습니다. 그러나 일을 더 복잡하게 만드십시오-RandClass ()의 ctor를 사용하지 않는 한 ctor를 호출하지 않기로 결정했습니다 ... 그래서 내 코드에서 전역 적으로 싱글 톤을 초기화하고 싶지 않았습니다. 또한 필자의 경우 간단한 인터페이스를 추가했습니다.

최종 코드는 다음과 같습니다.

코드를 단순화하고 rand () 함수와 단일 시드 이니셜 라이저 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();
}

다음은 EFraim 솔루션의 변형입니다. 차이점은 암시 적 템플릿 인스턴스화 덕분에 클래스의 인스턴스가 생성 된 경우에만 정적 생성자가 호출되고.cpp 파일에 가 필요 마법 입니다.

에서 .h파일, 당신은 :

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;

에서 .cpp파일, 당신은 할 수 있습니다 :

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

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

참고 MyClass::a그 다음 호출의 인스턴스를 필요 생성자 (및 인스턴스화 필요) 때문에, 라인 [1]이있는 경우에만 초기화된다 _initializer.

익명 네임 스페이스를 사용하여 구현이 포함 된 파일의 벡터가 개인용 인 다른 방법이 있습니다. 구현 전용 인 룩업 테이블과 같은 것들에 유용합니다.

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

현재 받아 들여지는 답변 (Daniel Earwicker의 답변)만큼 복잡 할 필요는 없습니다. 수업은 불필요합니다. 이 경우 언어 전쟁이 필요하지 않습니다.

.hpp 파일 :

vector<char> const & letters();

.cpp 파일 :

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

GCC 제공

__attribute__((constructor))

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

이 속성으로 정적 메소드에 태그를 지정하면 main () 전에 모듈로드시 실행됩니다.

멤버 메소드를 정의하는 방식과 유사하게 정적 멤버 변수를 정의합니다.

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;

정적 변수를 초기화하려면 소스 파일 내부에서 수행하십시오. 예를 들면 다음과 같습니다.

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


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

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

여기와 같은 간단한 경우 정적 멤버 함수 안에 싸인 정적 변수가 거의 좋습니다. 간단하고 일반적으로 컴파일러에 의해 최적화됩니다. 그래도 복잡한 객체의 초기화 순서 문제는 해결되지 않습니다.

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

이것이 해결책입니까?

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

정적 생성자는 아래와 같이 friend 클래스 또는 중첩 클래스를 사용하여 에뮬레이션 할 수 있습니다.

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

산출:

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 #의 정적 생성자 동작을 가장 가깝게 모방 한 사람, 즉 해당 유형의 첫 번째 객체가 생성 될 때까지 호출되지 않습니다.

std::call_once()C ++ 11에서 사용 가능합니다. 그것을 사용할 수 없다면 정적 부울 클래스 변수와 비교 및 ​​교환 원자 연산으로 수행 할 수 있습니다. 생성자에서 클래스 정적 플래그를에서 false로 변경할 수 true있는지 확인하고, 그렇다면 정적 생성 코드를 실행할 수 있습니다.

추가 크레딧을 얻으려면 부울 대신 3 방향 플래그로 설정하십시오 (예 : 달리기, 달리기 및 실행 완료). 그런 다음 정적 생성자를 실행하는 인스턴스가 완료 될 때까지 해당 클래스의 다른 모든 인스턴스를 스핀 잠금 할 수 있습니다 (예 : 메모리 울타리를 실행 한 후 상태를 "실행 완료"로 설정). 스핀 락은 프로세서의 "일시 정지"명령을 실행하고 임계 값 등이 올 때마다 대기 시간을 두 배로 늘려야합니다. 표준 스핀 락킹 기술입니다.

C ++ 11 이 없는 경우 시작해야합니다.

여기 당신을 안내하는 의사 코드가 있습니다. 이것을 클래스 정의에 넣으십시오.

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

그리고 이것은 당신의 생성자에서 :

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