idioma correcto para std :: string constants?

Question

Tengo un mapa que representa un objeto DB. Quiero obtener los valores de los conocidos 'de ella

std::map<std::string, std::string> dbo; 
... 
std::string val = map["foo"]; 

todo bien, pero se me ocurre que "foo" se convierte en una cadena temporal en cada llamada. Seguramente sería mejor tener una std :: string constante (por supuesto, es probablemente una pequeña sobrecarga en comparación con el disco IO que acaba de obtener el objeto, pero sigue siendo una pregunta válida, creo). Entonces, ¿cuál es la expresión correcta para std :: string constants?

por ejemplo - que puede tener

const std::string FOO = "foo"; 

en un HDR, pero luego obtener múltiples copias

EDIT: Aún no hay respuestas ha dicho cómo declarar constantes std :: string. Ignora todo el problema del mapa, STL, etc. Una gran cantidad de código es muy std :: string oriented (la mía ciertamente lo es) y es natural querer constantes para ellos sin pagar una y otra vez por la asignación de memoria

EDIT2: sacó la pregunta secundaria respondida por PDF de Manuel, ejemplo adicional de mala expresión

EDIT3: Resumen de respuestas. Tenga en cuenta que no he incluido aquellos que sugirieron crear una nueva clase de cadena. Estoy decepcionado porque esperaba que hubiera algo simple que funcionaría solo en el archivo de encabezado (como const char * const). De todos modos

a) de Marca b

std::map<int, std::string> dict; 
const int FOO_IDX = 1; 
.... 
dict[FOO_IDX] = "foo"; 
.... 
std:string &val = dbo[dict[FOO_IDX]]; 

b) de Vlad

// str.h 
extern const std::string FOO; 
// str.cpp 
const std::string FOO = "foo"; 

c) de Roger P

// really you cant do it 

(b) parece el más cercano a lo que quería pero tiene un defecto fatal. No puedo tener un código de nivel de módulo estático que use estas cadenas ya que es posible que aún no se hayan construido. Pensé en (a) y, de hecho, utilizar un truco similar al serializar el objeto, enviar el índice en lugar de la cadena, pero parecía una gran cantidad de plomería para una solución de propósito general. Así que por desgracia (c) ha sufrido, no hay sencilla idioma const para std: cadena

Answer 1

La copia y la falta de "cadena de optimización literal" se lo std :: trabajan cuerdas, y no se puede conseguir exactamente lo que' preguntando por En parte esto se debe a que los métodos virtuales y dtor fueron explícitamente evitados. La interfaz std :: string es plenty complicado sin ellos, de todos modos.

El estándar requiere una cierta interfaz para std :: string y std :: map, y esas interfaces no permiten la optimización que desea (como "consecuencia involuntaria" de sus otros requisitos, en lugar de explícitamente). Al menos, no lo permiten si realmente quiere seguir todos los detalles del estándar. Y realmente quieres eso, especialmente cuando es tan fácil usar una clase de cadena diferente para esta optimización específica.

Sin embargo, esa clase de cadena separada puede resolver estos "problemas" (como usted dijo, rara vez es un problema), pero desafortunadamente el mundo ya tiene number_of_programmers + 1. Incluso teniendo en cuenta la reinvención de la rueda, he encontrado que es útil tener una clase StaticString, que tiene un subconjunto de la interfaz de std :: string: usando begin/end, substr, find, etc.También impide la modificación (y se ajusta a los literales de cadena de esa manera), almacenando solo un puntero de char y un tamaño. Tiene que ser un poco cuidadoso que sólo ha inicializado con literales de cadena u otros datos "estáticos", pero eso es algo mitigada por la interfaz de construcción:

struct StaticString { 
    template<int N> 
    explicit StaticString(char (&data)[N]); // reference to char array 
    StaticString(StaticString const&); // copy ctor (which is very cheap) 

    static StaticString from_c_str(char const* c_str); // static factory function 
    // this only requires that c_str not change and outlive any uses of the 
    // resulting object(s), and since it must also be called explicitly, those 
    // requirements aren't hard to enforce; this is provided because it's explicit 
    // that strlen is used, and it is not embedded-'\0'-safe as the 
    // StaticString(char (&data)[N]) ctor is 

    operator char const*() const; // implicit conversion "operator" 
    // here the conversion is appropriate, even though I normally dislike these 

private: 
    StaticString(); // not defined 
}; 

Uso:

StaticString s ("abc"); 
assert(s != "123"); // overload operators for char* 
some_func(s); // implicit conversion 
some_func(StaticString("abc")); // temporary object initialized from literal 

Nota la principal ventaja de esta clase es explícitamente evitar copiar datos de cadena, por lo que el almacenamiento literal de cadena puede ser reutilizado. Hay un lugar especial en el ejecutable para estos datos, y generalmente está bien optimizado ya que data de los primeros días de C y más allá. De hecho, creo que esta clase está cerca de lo que los literales de cadena deberían haber sido en C++, si no fuera por el requisito de compatibilidad de C.

Por extensión, también podría escribir su propia clase de mapa si este es un escenario muy común para usted, y eso podría ser más fácil que cambiar los tipos de cadena.

Answer 2

1. Es posible evitar la sobrecarga de crear un std::string cuando lo que quieres es una cadena constante. Pero necesitarás escribir una clase especial para eso porque no hay nada similar en el STL o en Boost. O una mejor alternativa es usar una clase como StringPiece de Chromium o StringRef de LLVM. Consulte esto related thread para obtener más información.

2. Si decide quedarse con std::string (que probablemente lo hará) y luego otra buena opción es utilizar el contenedor MultiIndex Boost, que tiene la siguiente función (citando the docs):

   Boost MultiIndex [. ..] proporciona operaciones de búsqueda que aceptan las claves de búsqueda diferentes del tipo de clave del índice , que es una función especialmente útil cuando los objetos de tipo_clave son caros de crear.

Maps with Expensive Keys por Andrei Alexandrescu (C/C++ Diario de Usuarios, febrero de 2006) se relaciona con su problema y es una muy buena lectura.

Answer 3

El problema es que std::map copia la clave y los valores en sus propias estructuras.

Puede tener un std::map<const char *, const char *>, pero debe proporcionar objetos funcionales (o funciones) para comparar la clave y los datos de valor, ya que esta galería de símbolos es para los punteros. De forma predeterminada, el map compararía los punteros y no los datos a los que apuntan los punteros.

La compensación es una copia única (std::string) contra el acceso a un comparador (const char *).

Otra alternativa es escribir su propia función map.

Answer 4

El idioma correcto es el que estás usando. 99.99% del tiempo no hay necesidad de preocuparse por la sobrecarga del constructor de std :: string.

¿Me pregunto si el constructor de std :: string podría convertirse en una función intrínseca por un compilador?Teóricamente podría ser posible, pero mi comentario anterior sería una explicación suficiente de por qué no ha sucedido.

Answer 5

Parece que ya sabe cuáles serán los literales de cadena en tiempo de ejecución, por lo que puede configurar una asignación interna entre los valores enumerados y una matriz de cadenas. Luego usaría la enumeración en lugar de un literal const char * real en su código.

enum ConstStrings 
{ 
    MAP_STRING, 
    FOO_STRING, 
    NUM_CONST_STRINGS 
}; 

std::string constStrings[NUM_CONST_STRINGS]; 

bool InitConstStrings() 
{ 
    constStrings[MAP_STRING] = "map"; 
    constStrings[FOO_STRING] = "foo"; 
} 

// Be careful if you need to use these strings prior to main being called. 
bool doInit = InitConstStrings(); 

const std::string& getString(ConstStrings whichString) 
{ 
    // Feel free to do range checking if you think people will lie to you about the parameter type. 
    return constStrings[whichString]; 
} 

Entonces usted diría map[getString(MAP_STRING)] o similar.

Como acotación al margen, también consideran que almacena el valor devuelto por la referencia constante en lugar de copia si no es necesario modificarlo:

const std::string& val = map["foo"]; 

Answer 6

Es muy sencillo: utilizar

extern const std::string FOO; 

en su cabecera, y

const std::string FOO("foo"); 

en el archivo correspondiente .cpp.

Answer 7

En C++ 14 que puede hacer

const std::string FOO = "foo"s; 

Answer 8

creo que lo que estás buscando es 'impulso :: peso mosca < std :: string>'

esto es una referencia lógicamente const a un valor de cadena compartido. almacenamiento muy eficiente y alto rendimiento.

Answer 9

Mi solución (que tiene la ventaja de ser capaz de utilizar C++ 11 características que no estaban presentes cuando esta pregunta fue respondida con anterioridad):

#define INTERN(x) ([]() -> std::string const & { \ 
    static const std::string y = x; \ 
    return y; \ 
}()) 

my_map[INTERN("key")] = 5; 

Sí, es una macro y podría usar una mejor nombre