Cadena constante estática (miembro de la clase)

Me gustaría tener una constante estática privada para una clase (en este caso, una fábrica de formas).

Me gustaría tener algo por el estilo.

class A {
   private:
      static const string RECTANGLE = "rectangle";
}

Desafortunadamente, recibo todo tipo de errores del compilador de C ++ (g ++), como:

ISO C ++ prohíbe la inicialización del miembro 'RECTANGLE'

Inicialización en clase no válida del miembro de datos estáticos de tipo no integral 'std :: string'

error: haciendo estático 'RECTANGLE'

Esto me dice que este tipo de diseño de miembro no cumple con el estándar. ¿Cómo se tiene una constante literal privada (o quizás pública) sin tener que usar una directiva #define (¡quiero evitar la fealdad de la globalidad de los datos!)

Cualquier ayuda es apreciada.

Debe definir su miembro estático fuera de la definición de clase y proporcionar el inicializador allí.

primero

// In a header file (if it is in a header file in your case)
class A {   
private:      
  static const string RECTANGLE;
};

y entonces

// In one of the implementation files
const string A::RECTANGLE = "rectangle";

La sintaxis que originalmente intentaba usar (inicializador dentro de la definición de clase) solo se permite con tipos integrales y enum.

A partir de C ++ 17, tiene otra opción, que es bastante similar a su declaración original: variables en línea

// In a header file (if it is in a header file in your case)
class A {   
private:      
  inline static const string RECTANGLE = "rectangle";
};

No se necesita una definición adicional.

O en lugar de constusted puede declararlo constexpren esta variante. Explícito inlineya no sería necesario, ya que constexprimplica inline.

En C ++ 11 puedes hacer ahora:

class A {
 private:
  static constexpr const char* STRING = "some useful string constant";
};

Dentro de las definiciones de clase solo puede declarar miembros estáticos. Tienen que ser definidos fuera de la clase. Para las constantes integrales en tiempo de compilación, el estándar hace la excepción de que puede "inicializar" miembros. Sin embargo, todavía no es una definición. Tomar la dirección no funcionaría sin definición, por ejemplo.

Me gustaría mencionar que no veo el beneficio de usar std :: string sobre const char [] para constantes . std :: string es agradable y todo pero requiere una inicialización dinámica. Entonces, si escribes algo como

const std::string foo = "hello";

en el ámbito del espacio de nombres, el constructor de foo se ejecutará justo antes de la ejecución de los inicios principales y este constructor creará una copia de la constante "hola" en la memoria del montón. A menos que realmente necesite RECTANGLE para ser un std :: string, también podría escribir

// class definition with incomplete static member could be in a header file
class A {
    static const char RECTANGLE[];
};

// this needs to be placed in a single translation unit only
const char A::RECTANGLE[] = "rectangle";

¡Allí! Sin asignación de montón, sin copia, sin inicialización dinámica.

Saludos, s.

Esto es solo información adicional, pero si realmente desea la cadena en un archivo de encabezado, intente algo como:

class foo
{
public:
    static const std::string& RECTANGLE(void)
    {
        static const std::string str = "rectangle";

        return str;
    }
};

Aunque dudo que sea recomendable.

En C ++ 17 puede usar variables en línea :

class A {
 private:
  static inline const std::string my_string = "some useful string constant";
};

Tenga en cuenta que esto es diferente de la respuesta de abyss.7 : este define un std::stringobjeto real , no unconst char*

Para usar esa sintaxis de inicialización en clase, la constante debe ser una constante estática de tipo integral o de enumeración inicializada por una expresión constante.

Esta es la restricción. Por lo tanto, en este caso necesita definir variables fuera de la clase. refiera la respuesta de @AndreyT

Las variables estáticas de clase se pueden declarar en el encabezado pero se deben definir en un archivo .cpp. Esto se debe a que solo puede haber una instancia de una variable estática y el compilador no puede decidir en qué archivo de objeto generado colocarlo, por lo que debe tomar la decisión.

Para mantener la definición de un valor estático con la declaración en C ++ 11, se puede utilizar una estructura estática anidada. En este caso, el miembro estático es una estructura y debe definirse en un archivo .cpp, pero los valores están en el encabezado.

class A
{
private:
  static struct _Shapes {
     const std::string RECTANGLE {"rectangle"};
     const std::string CIRCLE {"circle"};
  } shape;
};

En lugar de inicializar miembros individuales, toda la estructura estática se inicializa en .cpp:

A::_Shapes A::shape;

Se accede a los valores con

A::shape.RECTANGLE;

o - dado que los miembros son privados y están destinados a ser utilizados solo desde A - con

shape.RECTANGLE;

Tenga en cuenta que esta solución aún adolece del problema del orden de inicialización de las variables estáticas. Cuando se usa un valor estático para inicializar otra variable estática, la primera puede no inicializarse todavía.

// file.h
class File {
public:
  static struct _Extensions {
    const std::string h{ ".h" };
    const std::string hpp{ ".hpp" };
    const std::string c{ ".c" };
    const std::string cpp{ ".cpp" };
  } extension;
};

// file.cpp
File::_Extensions File::extension;

// module.cpp
static std::set<std::string> headers{ File::extension.h, File::extension.hpp };

En este caso, los encabezados de las variables estáticas contendrán {""} o {".h", ".hpp"}, según el orden de inicialización creado por el vinculador.

Como mencionó @ abyss.7, también podría usar constexprsi el valor de la variable se puede calcular en tiempo de compilación. Pero si declara sus cadenas con static constexpr const char*y su programa usa lo std::stringcontrario, habrá una sobrecarga porque se std::stringcreará un nuevo objeto cada vez que use una constante de este tipo:

class A {
public:
   static constexpr const char* STRING = "some value";
};
void foo(const std::string& bar);
int main() {
   foo(A::STRING); // a new std::string is constructed and destroyed.
}

El estándar actual solo permite dicha inicialización para los tipos integrales constantes estáticos. Entonces debes hacer lo que AndreyT explicó. Sin embargo, eso estará disponible en el próximo estándar a través de la sintaxis de inicialización del nuevo miembro .

posible solo haz:

static const std::string RECTANGLE() const {
    return "rectangle";
} 

o

#define RECTANGLE "rectangle"

Puede optar por la const char*solución mencionada anteriormente, pero si necesita una secuencia todo el tiempo, tendrá una sobrecarga.
Por otro lado, la cadena estática necesita una inicialización dinámica, por lo tanto, si desea utilizar su valor durante la inicialización de otra variable global / estática, puede encontrar el problema del orden de inicialización. Para evitar eso, lo más barato es acceder al objeto de cadena estática a través de un getter, que verifica si su objeto está inicializado o no.

//in a header  
class A{  
  static string s;   
public:   
  static string getS();  
};  
//in implementation  
string A::s;  
namespace{  
  bool init_A_s(){  
    A::s = string("foo");   
    return true;  
  }  
  bool A_s_initialized = init_A_s();  
}  
string A::getS(){      
  if (!A_s_initialized)  
    A_s_initialized = init_A_s();  
  return s;  
}  

Recuerde usar solo A::getS(). Debido a que cualquier subproceso solo puede iniciarse main()y A_s_initializedse inicializa antes main(), no necesita bloqueos incluso en un entorno multiproceso. A_s_initializedes 0 de forma predeterminada (antes de la inicialización dinámica), por lo que si usa getS()antes de que se inicialice s, llamará a la función init de forma segura.

Por cierto, en la respuesta anterior: " static const std :: string RECTANGLE () const ", las funciones estáticas no pueden serconst porque no pueden cambiar el estado si algún objeto de todos modos (no hay este puntero).

Avance rápido a 2018 y C ++ 17.

• no use std :: string, use std :: string_view literales
• tenga en cuenta el 'constexpr' a continuación. Este también es un mecanismo de "tiempo de compilación".
• no en línea no significa repetición
• no se necesitan archivos cpp para esto

• static_assert 'funciona' solo en tiempo de compilación

  using namespace std::literals;
  
  namespace STANDARD {
  constexpr 
  inline 
  auto 
  compiletime_static_string_view_constant() {
  // make and return string view literal
  // will stay the same for the whole application lifetime
  // will exhibit standard and expected interface
  // will be usable at both
  // runtime and compile time
  // by value semantics implemented for you
      auto when_needed_ =  "compile time"sv;
      return when_needed_  ;
  }

  };

Arriba está un ciudadano C ++ estándar apropiado y legal. Puede involucrarse fácilmente en cualquiera y todos los algoritmos std ::, contenedores, utilidades y demás. Por ejemplo:

// test the resilience
auto return_by_val = []() {
    auto return_by_val = []() {
        auto return_by_val = []() {
            auto return_by_val = []() {
return STANDARD::compiletime_static_string_view_constant();
            };
            return return_by_val();
        };
        return return_by_val();
    };
    return return_by_val();
};

// actually a run time 
_ASSERTE(return_by_val() == "compile time");

// compile time 
static_assert(
   STANDARD::compiletime_static_string_view_constant() 
   == "compile time" 
 );

Disfruta del estándar C ++