Chaîne constante statique (membre de la classe)

Je voudrais avoir une constante statique privée pour une classe (dans ce cas, une fabrique de formes).

J'aimerais avoir quelque chose du genre.

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

Malheureusement, j'obtiens toutes sortes d'erreurs du compilateur C ++ (g ++), telles que:

ISO C ++ interdit l'initialisation du membre 'RECTANGLE'

initialisation en classe non valide d'un membre de données statiques de type non intégral 'std :: string'

erreur: rendre 'RECTANGLE' statique

Cela m'indique que ce type de conception de membre n'est pas conforme à la norme. Comment avez-vous une constante littérale privée (ou peut-être publique) sans avoir à utiliser une directive #define (je veux éviter la laideur de la globalité des données!)

Toute aide est appréciée.

Vous devez définir votre membre statique en dehors de la définition de classe et y fournir l'initialiseur.

Première

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

et alors

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

La syntaxe que vous essayiez à l'origine d'utiliser (initialiseur dans la définition de classe) n'est autorisée qu'avec les types intégral et enum.

À partir de C ++ 17, vous avez une autre option, qui est assez similaire à votre déclaration d'origine: les variables en ligne

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

Aucune définition supplémentaire n'est nécessaire.

Ou au lieu de constvous pouvez le déclarer constexprdans cette variante. Explicite inlinene serait plus nécessaire, car constexprimplique inline.

En C ++ 11, vous pouvez maintenant:

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

Dans les définitions de classe, vous ne pouvez déclarer que des membres statiques. Ils doivent être définis en dehors de la classe. Pour les constantes intégrales au moment de la compilation, la norme fait l'exception que vous pouvez «initialiser» les membres. Ce n'est toujours pas une définition, cependant. Prendre l'adresse ne fonctionnerait pas sans définition, par exemple.

Je voudrais mentionner que je ne vois pas l'avantage d'utiliser std :: string sur const char [] pour les constantes . std :: string est sympa et tout mais nécessite une initialisation dynamique. Donc, si vous écrivez quelque chose comme

const std::string foo = "hello";

au niveau de l'espace de noms, le constructeur de foo sera exécuté juste avant l'exécution du démarrage principal et ce constructeur créera une copie de la constante "hello" dans la mémoire du tas. Sauf si vous avez vraiment besoin que RECTANGLE soit une chaîne std ::, vous pourriez tout aussi bien écrire

// 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à! Pas d'allocation de tas, pas de copie, pas d'initialisation dynamique.

Santé, art.

Ce ne sont que des informations supplémentaires, mais si vous voulez vraiment la chaîne dans un fichier d'en-tête, essayez quelque chose comme:

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

        return str;
    }
};

Bien que je doute que ce soit recommandé.

En C ++ 17, vous pouvez utiliser des variables en ligne :

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

Notez que ceci est différent de la réponse d' abyss.7 : Celui-ci définit un std::stringobjet réel , pas unconst char*

Pour utiliser cette syntaxe d'initialisation en classe, la constante doit être une constante statique de type intégral ou énumération initialisée par une expression constante.

C'est la restriction. Par conséquent, dans ce cas, vous devez définir une variable en dehors de la classe. renvoyer une réponse de @AndreyT

Les variables statiques de classe peuvent être déclarées dans l'en-tête mais doivent être définies dans un fichier .cpp. En effet, il ne peut y avoir qu'une seule instance d'une variable statique et le compilateur ne peut pas décider dans quel fichier objet généré le placer, vous devez donc prendre la décision à la place.

Pour conserver la définition d'une valeur statique avec la déclaration en C ++ 11, une structure statique imbriquée peut être utilisée. Dans ce cas, le membre statique est une structure et doit être défini dans un fichier .cpp, mais les valeurs sont dans l'en-tête.

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

Au lieu d'initialiser des membres individuels, toute la structure statique est initialisée en .cpp:

A::_Shapes A::shape;

Les valeurs sont accessibles avec

A::shape.RECTANGLE;

ou - puisque les membres sont privés et sont destinés à être utilisés uniquement à partir de A - avec

shape.RECTANGLE;

Notez que cette solution souffre toujours du problème de l'ordre d'initialisation des variables statiques. Lorsqu'une valeur statique est utilisée pour initialiser une autre variable statique, la première peut ne pas encore être initialisée.

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

Dans ce cas, la variable statique têtes des contiendront {""} ou {".h", ".hpp"}, selon l'ordre d'initialisation créé par l'éditeur de liens.

Comme mentionné par @ abyss.7, vous pouvez également utiliser constexprsi la valeur de la variable peut être calculée au moment de la compilation. Mais si vous déclarez vos chaînes avec static constexpr const char*et que votre programme utilise std::stringautrement, il y aura une surcharge car un nouvel std::stringobjet sera créé chaque fois que vous utiliserez une telle 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.
}

La norme actuelle ne permet une telle initialisation que pour les types intégraux à constante statique. Vous devez donc faire comme AndreyT l'a expliqué. Cependant, cela sera disponible dans la prochaine norme via la nouvelle syntaxe d'initialisation des membres .

possible juste faire:

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

ou

#define RECTANGLE "rectangle"

Vous pouvez soit opter pour la const char*solution mentionnée ci-dessus, mais si vous avez besoin de chaîne tout le temps, vous aurez beaucoup de frais généraux.
D'un autre côté, la chaîne statique a besoin d'une initialisation dynamique, donc si vous souhaitez utiliser sa valeur lors de l'initialisation d'une autre variable globale / statique, vous pourriez rencontrer le problème de l'ordre d'initialisation. Pour éviter cela, le moins cher est d'accéder à l'objet chaîne statique via un getter, qui vérifie si votre objet est initialisé ou non.

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

N'oubliez pas d'utiliser uniquement A::getS(). Parce que tout threading ne peut être démarré que par main(), etA_s_initialized est initialisé auparavant main(), vous n'avez pas besoin de verrous même dans un environnement multithread. A_s_initializedest 0 par défaut (avant l'initialisation dynamique), donc si vous utilisezgetS() avant que s soit initialisé, vous appelez la fonction init en toute sécurité.

Btw, dans la réponse ci-dessus: " statique const std :: string RECTANGLE () const ", les fonctions statiques ne peuvent pas être constparce qu'elles ne peuvent pas changer l'état si un objet de toute façon (il n'y a pas ce pointeur).

Avance rapide vers 2018 et C ++ 17.

• n'utilisez pas std :: string, utilisez std :: string_view literals
• veuillez noter le soufflet «constexpr». Il s'agit également d'un mécanisme de "temps de compilation".
• pas en ligne ne signifie pas la répétition
• aucun fichier cpp n'est nécessaire pour cela

• static_assert 'fonctionne' au moment de la compilation uniquement

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

  };

Ci-dessus est un citoyen C ++ standard approprié et légal. Il peut être facilement impliqué dans tous les algorithmes std ::, conteneurs, utilitaires et autres. Par exemple:

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

Profitez du C ++ standard