¿Cómo inicializar miembros estáticos privados en C ++?

¿Cuál es la mejor manera de inicializar un miembro de datos estático privado en C ++? Intenté esto en mi archivo de encabezado, pero me da errores raros de enlazador:

class foo
{
    private:
        static int i;
};

int foo::i = 0;

Supongo que esto se debe a que no puedo inicializar un miembro privado desde fuera de la clase. Entonces, ¿cuál es la mejor manera de hacer esto?

La declaración de clase debe estar en el archivo de encabezado (o en el archivo de origen si no se comparte).
Archivo: foo.h

class foo
{
    private:
        static int i;
};

Pero la inicialización debe estar en el archivo fuente.
Archivo: foo.cpp

int foo::i = 0;

Si la inicialización está en el archivo de encabezado, entonces cada archivo que incluye el archivo de encabezado tendrá una definición del miembro estático. Por lo tanto, durante la fase de enlace, obtendrá errores de enlace ya que el código para inicializar la variable se definirá en múltiples archivos de origen. La inicialización de la static int idebe hacerse fuera de cualquier función.

Nota: Matt Curtis: señala que C ++ permite la simplificación de lo anterior si la variable miembro estática es de tipo int constante (p int. Ej . bool, char). Luego puede declarar e inicializar la variable miembro directamente dentro de la declaración de clase en el archivo de encabezado:

class foo
{
    private:
        static int const i = 42;
};

Para una variable :

foo.h:

class foo
{
private:
    static int i;
};

foo.cpp:

int foo::i = 0;

Esto se debe a que solo puede haber una instancia foo::ien su programa. Es una especie de equivalente extern int ien un archivo de encabezado y int ien un archivo fuente.

Para una constante , puede poner el valor directamente en la declaración de clase:

class foo
{
private:
    static int i;
    const static int a = 42;
};

Desde C ++ 17, los miembros estáticos pueden definirse en el encabezado con la palabra clave en línea .

http://en.cppreference.com/w/cpp/language/static

"Un miembro de datos estáticos puede declararse en línea. Un miembro de datos estáticos en línea puede definirse en la definición de clase y puede especificar un inicializador de miembro predeterminado. No necesita una definición fuera de clase:"

struct X
{
    inline static int n = 1;
};

Para los futuros espectadores de esta pregunta, quiero señalar que deben evitar lo que monkey0506 sugiere .

Los archivos de encabezado son para declaraciones.

Los archivos de encabezado se compilan una vez por cada .cpparchivo que los directa o indirectamente #includes, y el código fuera de cualquier función se ejecuta en la inicialización del programa, antesmain() .

Al poner: foo::i = VALUE;en el encabezado, foo:ise le asignará el valor VALUE(lo que sea que sea) para cada .cpparchivo, y estas asignaciones sucederán en un orden indeterminado (determinado por el vinculador) antes de main()ejecutarse.

¿Qué pasa si somos #define VALUEun número diferente en uno de nuestros .cpparchivos? Se compilará bien y no tendremos forma de saber cuál gana hasta que ejecutemos el programa.

Nunca coloque el código ejecutado en un encabezado por la misma razón que nunca #includeun .cpparchivo.

incluir guardias (que estoy de acuerdo en que siempre debe usar) lo protegen de algo diferente: el mismo encabezado se usa indirectamente #includevarias veces al compilar un solo .cpparchivo

Con un compilador de Microsoft [1], las variables estáticas que no son intsimilares también se pueden definir en un archivo de encabezado, pero fuera de la declaración de clase, utilizando el específico de Microsoft __declspec(selectany).

class A
{
    static B b;
}

__declspec(selectany) A::b;

Tenga en cuenta que no digo que esto sea bueno, solo digo que se puede hacer.

[1] En estos días, hay más compiladores que el soporte de MSC __declspec(selectany), al menos gcc y clang. Quizás aún más.

int foo::i = 0; 

Es la sintaxis correcta para inicializar la variable, pero debe ir en el archivo fuente (.cpp) en lugar de en el encabezado.

Debido a que es una variable estática, el compilador necesita crear solo una copia de ella. Debe tener una línea "int foo: i" en algún lugar de su código para indicarle al compilador dónde colocarlo; de lo contrario, obtendrá un error de enlace. Si está en un encabezado, obtendrá una copia en cada archivo que incluya el encabezado, por lo tanto, obtenga múltiples errores de símbolos definidos desde el enlazador.

No tengo suficiente representante aquí para agregar esto como un comentario, pero en mi opinión, es un buen estilo escribir sus encabezados con #include guardias de todos modos, lo que, como señaló Paranaix hace unas horas, evitaría un error de definición múltiple. A menos que ya esté usando un archivo CPP separado, no es necesario usar uno solo para inicializar miembros no integrales estáticos.

#ifndef FOO_H
#define FOO_H
#include "bar.h"

class foo
{
private:
    static bar i;
};

bar foo::i = VALUE;
#endif

No veo la necesidad de usar un archivo CPP separado para esto. Claro que puedes, pero no hay una razón técnica por la que debas hacerlo.

Si desea inicializar algún tipo compuesto (cadena fe), puede hacer algo así:

class SomeClass {
  static std::list<string> _list;

  public:
    static const std::list<string>& getList() {
      struct Initializer {
         Initializer() {
           // Here you may want to put mutex
           _list.push_back("FIRST");
           _list.push_back("SECOND");
           ....
         }
      }
      static Initializer ListInitializationGuard;
      return _list;
    }
};

Como ListInitializationGuardes un SomeClass::getList()método interno de variable estática , se construirá solo una vez, lo que significa que se llama al constructor una vez. Esto variará initialize _listal valor que necesita. Cualquier llamada posterior a getListsimplemente devolverá el _listobjeto ya inicializado .

Por supuesto, debe acceder al _listobjeto siempre llamando al getList()método.

Patrón de constructor estático C ++ 11 que funciona para múltiples objetos

Se propuso un modismo en: https://stackoverflow.com/a/27088552/895245, pero aquí hay una versión más limpia que no requiere la creación de un nuevo método por miembro.

main.cpp

#include <cassert>
#include <vector>

// Normally on the .hpp file.
class MyClass {
public:
    static std::vector<int> v, v2;
    static struct StaticConstructor {
        StaticConstructor() {
            v.push_back(1);
            v.push_back(2);
            v2.push_back(3);
            v2.push_back(4);
        }
    } _staticConstructor;
};

// Normally on the .cpp file.
std::vector<int> MyClass::v;
std::vector<int> MyClass::v2;
// Must come after every static member.
MyClass::StaticConstructor MyClass::_staticConstructor;

int main() {
    assert(MyClass::v[0] == 1);
    assert(MyClass::v[1] == 2);
    assert(MyClass::v2[0] == 3);
    assert(MyClass::v2[1] == 4);
}

GitHub aguas arriba .

Compilar y ejecutar:

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out

Ver también: constructores estáticos en C ++? Necesito inicializar objetos privados estáticos

Probado en Ubuntu 19.04.

C ++ 17 variable en línea

Mencionado en: https://stackoverflow.com/a/45062055/895245 pero aquí hay un ejemplo ejecutable de múltiples archivos para hacerlo aún más claro: ¿Cómo funcionan las variables en línea?

También puede incluir la asignación en el archivo de encabezado si usa protectores de encabezado. He usado esta técnica para una biblioteca C ++ que he creado. Otra forma de lograr el mismo resultado es usar métodos estáticos. Por ejemplo...

class Foo
   {
   public:
     int GetMyStatic() const
     {
       return *MyStatic();
     }

   private:
     static int* MyStatic()
     {
       static int mStatic = 0;
       return &mStatic;
     }
   }

El código anterior tiene la "ventaja" de no requerir un archivo CPP / fuente. De nuevo, un método que uso para mis bibliotecas C ++.

Sigo la idea de Karl. Me gusta y ahora también lo uso. He cambiado un poco la notación y agregué algunas funcionalidades

#include <stdio.h>

class Foo
{
   public:

     int   GetMyStaticValue () const {  return MyStatic();  }
     int & GetMyStaticVar ()         {  return MyStatic();  }
     static bool isMyStatic (int & num) {  return & num == & MyStatic(); }

   private:

      static int & MyStatic ()
      {
         static int mStatic = 7;
         return mStatic;
      }
};

int main (int, char **)
{
   Foo obj;

   printf ("mystatic value %d\n", obj.GetMyStaticValue());
   obj.GetMyStaticVar () = 3;
   printf ("mystatic value %d\n", obj.GetMyStaticValue());

   int valMyS = obj.GetMyStaticVar ();
   int & iPtr1 = obj.GetMyStaticVar ();
   int & iPtr2 = valMyS;

   printf ("is my static %d %d\n", Foo::isMyStatic(iPtr1), Foo::isMyStatic(iPtr2));
}

esto produce

mystatic value 7
mystatic value 3
is my static 1 0

También trabajando en el archivo privateStatic.cpp:

#include <iostream>

using namespace std;

class A
{
private:
  static int v;
};

int A::v = 10; // possible initializing

int main()
{
A a;
//cout << A::v << endl; // no access because of private scope
return 0;
}

// g++ privateStatic.cpp -o privateStatic && ./privateStatic

¿Qué hay de un set_default()método?

class foo
{
    public:
        static void set_default(int);
    private:
        static int i;
};

void foo::set_default(int x) {
    i = x;
}

Solo tendríamos que usar el set_default(int x)método y nuestra staticvariable se inicializaría.

Esto no estaría en desacuerdo con el resto de los comentarios, en realidad sigue el mismo principio de inicializar la variable en un ámbito global, pero al usar este método lo hacemos explícito (y fácil de ver y entender) en lugar de tener la definición de la variable colgando allí.

El problema del enlazador que encontró probablemente sea causado por:

• Proporcionando definición de miembro tanto de clase como estático en el archivo de encabezado,
• Incluyendo este encabezado en dos o más archivos de origen.

Este es un problema común para aquellos que comienzan con C ++. El miembro de clase estático debe inicializarse en una sola unidad de traducción, es decir, en un único archivo fuente.

Desafortunadamente, el miembro de la clase estática debe inicializarse fuera del cuerpo de la clase. Esto complica escribir código de solo encabezado y, por lo tanto, estoy usando un enfoque bastante diferente. Puede proporcionar su objeto estático a través de una función de clase estática o no estática, por ejemplo:

class Foo
{
    // int& getObjectInstance() const {
    static int& getObjectInstance() {
        static int object;
        return object;
    }

    void func() {
        int &object = getValueInstance();
        object += 5;
    }
};

Una forma "antigua" de definir constantes es reemplazarlas por enum:

class foo
{
    private:
        enum {i = 0}; // default type = int
        enum: int64_t {HUGE = 1000000000000}; // may specify another type
};

De esta manera, no es necesario proporcionar una definición y evita hacer el valor constante l , lo que puede ahorrarle algunos dolores de cabeza, por ejemplo, cuando lo usa ODR accidentalmente .

Solo quería mencionar algo un poco extraño para mí cuando me encontré con esto por primera vez.

Necesitaba inicializar un miembro privado de datos estáticos en una clase de plantilla.

en .h o .hpp, se ve algo así para inicializar un miembro de datos estáticos de una clase de plantilla:

template<typename T>
Type ClassName<T>::dataMemberName = initialValue;

¿Esto sirve a su propósito?

//header file

struct MyStruct {
public:
    const std::unordered_map<std::string, uint32_t> str_to_int{
        { "a", 1 },
        { "b", 2 },
        ...
        { "z", 26 }
    };
    const std::unordered_map<int , std::string> int_to_str{
        { 1, "a" },
        { 2, "b" },
        ...
        { 26, "z" }
    };
    std::string some_string = "justanotherstring";  
    uint32_t some_int = 42;

    static MyStruct & Singleton() {
        static MyStruct instance;
        return instance;
    }
private:
    MyStruct() {};
};

//Usage in cpp file
int main(){
    std::cout<<MyStruct::Singleton().some_string<<std::endl;
    std::cout<<MyStruct::Singleton().some_int<<std::endl;
    return 0;
}