Quiero tener una clase con un miembro privado de datos estáticos (un vector que contiene todos los caracteres az). En java o C #, simplemente puedo hacer un "constructor estático" que se ejecutará antes de hacer cualquier instancia de la clase, y configurar los miembros de datos estáticos de la clase. Solo se ejecuta una vez (ya que las variables son de solo lectura y solo necesitan configurarse una vez) y dado que es una función de la clase, puede acceder a sus miembros privados. Podría agregar código en el constructor que verifica si el vector se inicializa e inicializarlo si no es así, pero eso introduce muchas verificaciones necesarias y no parece ser la solución óptima para el problema.

Se me ocurre que, dado que las variables serán de solo lectura, solo pueden ser constantes estáticas públicas, por lo que puedo configurarlas una vez fuera de la clase, pero una vez más, parece una especie de truco feo.

¿Es posible tener miembros privados de datos estáticos en una clase si no quiero inicializarlos en el constructor de instancias?

Para obtener el equivalente de un constructor estático, debe escribir una clase ordinaria separada para contener los datos estáticos y luego hacer una instancia estática de esa clase ordinaria.

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

};

Bueno puedes tener

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

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

No olvides (en el .cpp) esto:

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

El programa aún se vinculará sin la segunda línea, pero el inicializador no se ejecutará.

Solución C ++ 11

Desde C ++ 11, simplemente puede usar expresiones lambda para inicializar miembros de clase estáticos. Esto incluso funciona si necesita imponer un orden de construcción entre los distintos miembros estáticos, o si tiene miembros estáticos que son const.

Archivo de cabecera:

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

Archivo fuente:

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

En el archivo .h:

class MyClass {
private:
    static int myValue;
};

En el archivo .cpp:

#include "myclass.h"

int MyClass::myValue = 0;

Aquí hay otro enfoque similar al de Daniel Earwicker, que también utiliza la sugerencia de clase de amigo de Konrad Rudolph. Aquí usamos una clase de utilidad de amigo privado interno para inicializar los miembros estáticos de su clase principal. Por ejemplo:

Archivo de cabecera:

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

Archivo de implementación:

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

Este enfoque tiene la ventaja de ocultar completamente la clase Initializer del mundo exterior, manteniendo todo lo contenido dentro de la clase para inicializar.

Test::StaticTest() se llama exactamente una vez durante la inicialización estática global.

La persona que llama solo tiene que agregar una línea a la función que será su constructor estático.

static_constructor<&Test::StaticTest>::c;fuerza la inicialización de cdurante la inicialización estática global.

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

Sin necesidad de una init()función, std::vectorse puede crear desde un rango:

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

Sin embargo, tenga en cuenta que las estadísticas de tipo de clase causan problemas en las bibliotecas, por lo que deben evitarse allí.

Actualización de C ++ 11

A partir de C ++ 11, puede hacer esto en su lugar:

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

Es semánticamente equivalente a la solución C ++ 98 en la respuesta original, pero no puede usar un literal de cadena en el lado derecho, por lo que no es completamente superior. Sin embargo, si tiene un vector de cualquier otro tipo que char, wchar_t, char16_to char32_t(arrays de los cuales se puede escribir como literales de cadena), la versión C ++ 11 eliminará estrictamente código repetitivo sin introducir otra sintaxis, en comparación con el C ++ 98 versión.

El concepto de constructores estáticos se introdujo en Java después de que aprendieron de los problemas en C ++. Entonces no tenemos un equivalente directo.

La mejor solución es usar tipos de POD que puedan inicializarse explícitamente.
O haga que sus miembros estáticos sean de un tipo específico que tenga su propio constructor que lo inicialice correctamente.

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

Cuando intento compilar y usar class Elsewhere(de la respuesta de Earwicker ) obtengo:

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

Parece que no es posible inicializar atributos estáticos de tipos no enteros sin poner algún código fuera de la definición de clase (CPP).

Para hacer esa compilación, puede usar " un método estático con una variable local estática dentro ". Algo como esto:

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

Y también puede pasar argumentos al constructor o inicializarlo con valores específicos, es muy flexible, potente y fácil de implementar ... lo único es que tiene un método estático que contiene una variable estática, no un atributo estático ... La sintaxis cambia un poco, pero sigue siendo útil. Espero que esto sea útil para alguien,

Hugo González Castro.

Supongo que la solución simple a esto será:

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

Acabo de resolver el mismo truco. Tuve que especificar la definición de un solo miembro estático para Singleton. Pero haga las cosas más complicadas: he decidido que no quiero llamar al ctor de RandClass () a menos que lo use ... es por eso que no quería inicializar singleton globalmente en mi código. También he agregado una interfaz simple en mi caso.

Aquí está el código final:

Simplifiqué el código y utilicé la función rand () y su inicializador de inicio único 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();
}

Aquí está mi variante de la solución de EFraim; la diferencia es que, gracias a la creación de instancias implícita de plantilla, el constructor estático solo se llama si se crean instancias de la clase, y que no .cppse necesita ninguna definición en el archivo (gracias a la magia de creación de instancias de plantilla).

En el .harchivo, tienes:

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;

En el .cpparchivo, puede tener:

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

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

Tenga en cuenta que MyClass::asolo se inicializa si la línea [1] está allí, porque eso llama (y requiere la creación de instancias) del constructor, que luego requiere la creación de instancias de _initializer.

Aquí hay otro método, donde el vector es privado para el archivo que contiene la implementación mediante el uso de un espacio de nombres anónimo. Es útil para cosas como tablas de búsqueda que son privadas para la implementación:

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

Ciertamente no necesita ser tan complicado como la respuesta actualmente aceptada (por Daniel Earwicker). La clase es superflua. No hay necesidad de una guerra de idiomas en este caso.

archivo .hpp:

vector<char> const & letters();

archivo .cpp:

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

Ofertas de GCC

__attribute__((constructor))

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

Etiquete un método estático con este atributo y se ejecutará en la carga del módulo, antes de main ().

Defina variables miembro estáticas de forma similar a la forma en que define los métodos miembros.

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;

Para inicializar una variable estática, solo debe hacerlo dentro de un archivo fuente. Por ejemplo:

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


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

¿Qué tal crear una plantilla para imitar el comportamiento de 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
    };
};

Para casos simples como aquí, una variable estática envuelta dentro de una función miembro estática es casi tan buena. Es simple y generalmente será compilado por los compiladores. Sin embargo, esto no resuelve el problema del orden de inicialización para objetos complejos.

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

¿Es esta una solución?

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

Se puede emular un constructor estático utilizando una clase amiga o una clase anidada como se muestra a continuación.

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

Salida:

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, no puedo creer que nadie mencionó la respuesta más obvia, y una que imita más estrechamente el comportamiento del constructor estático de C #, es decir, no se llama hasta que se crea el primer objeto de ese tipo.

std::call_once()está disponible en C ++ 11; si no puede usar eso, se puede hacer con una variable de clase booleana estática y una operación atómica de comparar e intercambiar. En su constructor, vea si puede cambiar atómicamente el indicador de clase estática de falsea true, y si es así, puede ejecutar el código de construcción estática.

Para obtener crédito adicional, conviértalo en un indicador de 3 vías en lugar de un valor booleano, es decir, no ejecutar, ejecutar y finalizar la ejecución. Luego, todas las demás instancias de esa clase pueden girar y bloquear hasta que la instancia que ejecuta el constructor estático haya finalizado (es decir, emita un límite de memoria, luego establezca el estado en "ejecución finalizada"). Su spin-lock debe ejecutar la instrucción de "pausa" del procesador, duplicar la espera cada vez hasta un umbral, etc. - técnica de bloqueo de spin bastante estándar.

En ausencia de C ++ 11, esto debería ayudarlo a comenzar.

Aquí hay un pseudocódigo para guiarte. Pon esto en la definición de tu clase:

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

Y esto en tu 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();