constantes de cadena estática en clase vs espacio de nombres para constantes [C++]

Question

Quiero declarar constantes de cadena que se utilizarán en varias clases en el proyecto. Estoy considerando dos alternativas

Opción 1:

#header file 
class constants{ 
    static const string const1; 
}; 

#cpp file 

const string constants::const1="blah"; 

Opción 2:

#header file 
namespace constants{ 
    static const string const1="blah"; 
}; 

Sólo me preguntaba lo que sería una mejor aplicación.

Ya miraron

Where to store Class Specific named constants in C++

Where to put constant strings in C++: static class members or anonymous namespaces

---

UPDATE:

Opción 3:

Basado en las sugerencias de "potatoswatter" y "sellibitze" actualmente tengo la siguiente implementación?

#header file 
namespace constants{ 
    extern const string& const1(); //WORKS WITHOUT THE EXTERN ***WHY*** 
}; 

#cpp file 
namespace constants{ 
    const string& const1(){static string* str = new string ("blah"); return *str;} 
} 

Estoy incluyendo el archivo de encabezado donde necesito usar las constantes. ¿Hay algún inconveniente importante de esta implementación?

Answer 1

^{Actualización 2 años más tarde:}

Cada accesibles mundial por más de un archivo de origen debe ser envuelto en una función inline por lo que las acciones de engarce el objeto entre los archivos y el programa inicializa correctamente.

inline std::string const &const1 { 
    static std::string ret = "hello, world!"; 
    return ret; 
} 

La función inline es implícitamente extern y se puede envolver en un espacio de nombres con nombre o una clase, si lo desea. (Pero no use una clase solo para contener miembros estáticos, ya que los espacios de nombres son mejores para eso. Y no use un espacio de nombre anónimo ya que eso vencería al enlazador, y cada fuente vería un objeto diferente std::string.)

Answer 2

Opción 1 logra lo mismo que la Opción 2, pero de una manera más desordenada.

Si va a utilizar una clase que solo tiene miembros estáticos, especialmente para acceso/constantes globales, use un espacio de nombres.

Answer 3

Ninguno. Me quedo con esto:

// header file 
namespace constants { 
extern const char const1[]; 
} 

// cpp file 
namespace constants { 
extern const char const1[] = "blah"; 
} 

El archivo de cabecera contiene una declaración de const1 con el tipo incompleto, pero convertible en char const* y el CPP-archivo contiene una definición de la matriz de caracteres con enlace externo. No hay inicialización dinámica como la que tiene con std::string. Entonces, eso es una ventaja, en mi humilde opinión.

Answer 4

Todas las respuestas que recurren a std::string corren el riesgo de asignar dinámicamente memoria para una cadena literal que se mantendrá constante durante toda la vida del programa (y el binario), por lo que deben evitarse.

sellibitze La respuesta se acerca, pero tiene el problema de declararla una vez y luego definirla en otro lugar, lo cual no me parece elegante y es más trabajo. La mejor manera sería

namespace constants { 
    const char * const blah = "blah!" 
    const char * const yada = "yada yada!" 
} 

Esta solución es se discute más here.