Llenar un recipiente miembro estático en C++

Question

Tengo un miembro de la clase estática que es un poco de contenedor, como

(foo.h)

class Foo 
{ 
    ... 
private: 
    static list<string> s_List; 
} 

que necesito para llenar la lista con un número de valores específicos En realidad, debería ser también const, pero que podría complicar aún más el problema. Todas las funciones miembro de clase son estáticos, por lo que la inicialización en un constructor no tiene sentido.

Answer 1

una solución común es hacer algo como esto:

// header 
class Foo 
{ 
... 
private: 
    static list<string> s_List; 
} 

// cpp 
list<string> init() 
{ 
    list<string> tmp; 
    ... fill tmp with strings 

    return tmp; 
} 

list<string> Foo::s_List(init()); 

el otro método es como Neil Butterworth sugirió.

Answer 2

Las formas en vano yo (el autor de la pregunta) hemos tratado de hacer esto.

---

he intentado hacer algo bajo como (en foo.cpp):

list<string> Foo::s_List = list<string>(); 
Foo::s_List.insert("apple"); 
Foo::s_List.insert("bannana"); 
Foo::s_List.insert("grapes"); 

Pero eso da un error de compilación.

---

entonces pensé en hacer un método initialize() y llamar a las cosas bien desde el código

void Foo::Initialize() 
{ 
    s_List.insert("rats"); 
    s_List.insert("cats"); 
} 

Foo::Initialize(); 

// error: compilador considera que es un redefenition del método, no una llamada.

---

La única idea viable que queda (havent probado todavía) sería comprobar si la lista está vacía en cada método que utiliza, y si es el caso, llamar a Initialize(). ¡Pero eso es feo!

Answer 3

una posible solución sería utilizar un método de acceso que comprueba para ver si se inicializa, y lo hace si no lo es.

Answer 4

Otra alternativa es crear una clase simple initialiser:

list <string> Foo::s_List; 

struct Init { 
    Init() { 
     Foo::s_List.insert("apple"); 
     Foo::s_List.insert("bannana"); 
     Foo::s_List.insert("grapes"); 
    } 
}; 

static Init doInit; 

Tenga en cuenta que, ya que la lista es privada, esto probablemente será necesario que para hacer Init un amigo de Foo. A menudo también es conveniente hacer que dichas clases estén contenidas en la clase que están inicializando.

Sin embargo, acabo de volver a leer su pregunta y ocurre otra idea: si la lista es const, presumiblemente no la cambiará, en cuyo caso una simple matriz de cadenas, inicializada con las cadenas en orden ordenado puede ser una mejor solución. Sin duda será más rápido para buscar (usando std :: binary_search) que una lista, y por supuesto puede ser inicializado con facilidad.

Answer 5

Depende de los valores que se necesita para poner en esa lista. ¿Están estáticos o requieren algún tipo de cálculo?

Si son estáticos, se puede hacer esto:

namespace { 
    const char* const initVals[] = { "A", "B", "C" }; 
} 

list<string> Foo::s_list(initVals, initVals + 3); 

Answer 6

Si su compilador soporta C++ 0x, esto es realmente trivial de lograr.

#include <iostream> 
#include <list> 

class Foo 
{ 
public: 
    static std::list<std::string> s_List; 
}; 

std::list<std::string> Foo::s_List = {"hello", "world", "asdf", "qwerty"}; 

int main() 
{ 
    for(const std::string& str : Foo::s_List) 
     std::cout << str << std::endl; 

    return 0; 
} 

Esto funciona para miembros estáticos const y non-const. Probé este fragmento con clang-4.2, gcc-4.7, gcc-4.6 y gcc-4.5. Gcc-4.5 no es compatible con la versión actualizada de sintaxis, por lo que tendría que utilizar un bucle tradicional para con iteradores. Además, no olvide pasar el indicador -std = C++ 0x al compilador. Estoy razonablemente seguro de que Visual Studio también lo admite, pero no estoy seguro y no sé qué versiones.