Sequência constante estática (membro da classe)

Eu gostaria de ter uma constante estática privada para uma classe (neste caso, uma fábrica de formas).

Eu gostaria de ter algo do tipo.

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

Infelizmente, recebo todos os tipos de erro do compilador C ++ (g ++), como:

O ISO C ++ proíbe a inicialização do membro 'RECTANGLE'

inicialização inválida na classe do membro de dados estáticos do tipo não integral 'std :: string'

erro: tornando 'RECTANGLE' estático

Isso me diz que esse tipo de design de membro não é compatível com o padrão. Como você tem uma constante literal privada (ou talvez pública) sem precisar usar uma diretiva #define (eu quero evitar a feia da globalidade dos dados!)

Qualquer ajuda é apreciada.

Você precisa definir seu membro estático fora da definição de classe e fornecer o inicializador lá.

Primeiro

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

e depois

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

A sintaxe que você estava originalmente tentando usar (inicializador dentro da definição de classe) é permitida apenas nos tipos integral e enum.

A partir do C ++ 17, você tem outra opção, que é bastante semelhante à sua declaração original: variáveis ​​inline

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

Nenhuma definição adicional é necessária.

Ou, em vez de constvocê, pode declarar constexprnesta variante. Explícito inlinenão seria mais necessário, pois constexprimplica inline.

No C ++ 11, você pode fazer agora:

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

Definições de classe interna, você só pode declarar membros estáticos. Eles precisam ser definidos fora da classe. Para constantes integrais em tempo de compilação, o padrão faz a exceção de que você pode "inicializar" membros. Ainda não é uma definição, no entanto. Tomar o endereço não funcionaria sem definição, por exemplo.

Eu gostaria de mencionar que não vejo o benefício de usar std :: string sobre const char [] para constantes . std :: string é bom e tudo, mas requer inicialização dinâmica. Então, se você escrever algo como

const std::string foo = "hello";

no escopo do espaço para nome, o construtor foo será executado logo antes da execução das principais partidas e esse construtor criará uma cópia da constante "hello" na memória heap. A menos que você realmente precise de RECTANGLE para ser um std :: string, você também pode escrever

// 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";

Lá! Sem alocação de heap, sem cópia, sem inicialização dinâmica.

Saúde, s.

Isso é apenas uma informação extra, mas se você realmente deseja a string em um arquivo de cabeçalho, tente algo como:

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

        return str;
    }
};

Embora eu duvide que seja recomendado.

No C ++ 17, você pode usar variáveis ​​embutidas :

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

Observe que isso é diferente da resposta do abyss.7 : Este define um std::stringobjeto real , não umconst char*

Para usar essa sintaxe de inicialização em classe, a constante deve ser uma const estática do tipo integral ou de enumeração inicializada por uma expressão constante.

Essa é a restrição. Portanto, nesse caso, você precisa definir variáveis ​​fora da classe. consulte resposta de @AndreyT

As variáveis ​​estáticas da classe podem ser declaradas no cabeçalho, mas devem ser definidas em um arquivo .cpp. Isso ocorre porque pode haver apenas uma instância de uma variável estática e o compilador não pode decidir em qual arquivo de objeto gerado o colocará, portanto, você deve tomar a decisão.

Para manter a definição de um valor estático com a declaração em C ++ 11, uma estrutura estática aninhada pode ser usada. Nesse caso, o membro estático é uma estrutura e deve ser definido em um arquivo .cpp, mas os valores estão no cabeçalho.

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

Em vez de inicializar membros individuais, toda a estrutura estática é inicializada em .cpp:

A::_Shapes A::shape;

Os valores são acessados ​​com

A::shape.RECTANGLE;

ou - como os membros são privados e devem ser usados ​​apenas em A - com

shape.RECTANGLE;

Observe que essa solução ainda sofre com o problema da ordem de inicialização das variáveis ​​estáticas. Quando um valor estático é usado para inicializar outra variável estática, a primeira ainda não pode ser inicializada.

// 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 };

Nesse caso, os cabeçalhos das variáveis ​​estáticas conterão {""} ou {".h", ".hpp"}, dependendo da ordem de inicialização criada pelo vinculador.

Conforme mencionado por @ abyss.7, você também pode usar constexprse o valor da variável puder ser calculado em tempo de compilação. Mas se você declarar suas strings com static constexpr const char*e seu programa usar de std::stringoutra forma, haverá uma sobrecarga porque um novo std::stringobjeto será criado toda vez que você usar essa constante:

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.
}

O padrão atual permite apenas essa inicialização para tipos integrais constantes estáticos. Então você precisa fazer o que o AndreyT explicou. No entanto, isso estará disponível no próximo padrão através da sintaxe de inicialização do novo membro .

possível apenas faça:

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

ou

#define RECTANGLE "rectangle"

Você pode optar pela const char*solução mencionada acima, mas se precisar de strings o tempo todo, terá muita sobrecarga.
Por outro lado, a cadeia estática precisa de inicialização dinâmica; portanto, se você quiser usar seu valor durante a inicialização de outra variável global / estática, poderá encontrar o problema da ordem de inicialização. Para evitar isso, o mais barato é acessar o objeto de cadeia estática por meio de um getter, que verifica se o seu objeto foi inicializado ou não.

//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;  
}  

Lembre-se de usar apenas A::getS(). Como qualquer encadeamento só pode ser iniciado main()e A_s_initializedinicializado antes main(), você não precisa de bloqueios, mesmo em um ambiente multithread. A_s_initializedé 0 por padrão (antes da inicialização dinâmica); portanto, se você usar getS()antes da inicialização de s, chame a função init com segurança.

Aliás, na resposta acima: " estática const std :: string RECTANGLE () const ", funções estáticas não podem ser constporque não podem alterar o estado de qualquer objeto de qualquer maneira (não existe esse ponteiro).

Avanço rápido para 2018 e C ++ 17.

• não use std :: string, use literais std :: string_view
• observe o abaixo 'constexpr'. Este também é um mecanismo de "tempo de compilação".
• sem inline não significa repetição
• nenhum arquivo cpp não é necessário para isso

• static_assert 'funciona' somente em tempo de compilação

  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_  ;
  }

  };

Acima está um cidadão C ++ padrão adequado e legal. Ele pode se envolver prontamente em todo e qualquer algoritmo std ::, contêineres, utilitários e similares. Por exemplo:

// 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" 
 );

Aproveite o C ++ padrão