static const membre de l'initialisation d'une variable

La syntaxe initializer in the class definition n'est autorisée qu'avec l'intégrale et les types d'énumérations. Pour std::string, il doit être défini en dehors de la définition de la classe et initialisé.

struct C {
  static const int a = 42;     
  static const string b; 
};

const string C::b = "hi"; //in one of the .cpp files

static members doit être défini dans une unité de traduction de remplir l'une définition de la règle. Si le C++ permet la définition ci-dessous;

struct C {
  static const string b = "hi"; 
};

b devrait être défini dans chaque unité de traduction qui comprend le fichier d'en-tête.

C++ ne permet que de définir const static de données des membres de integral ou enumeration type dans la déclaration de classe, comme un raccourci. La raison pour laquelle const static de données des membres d'autres types de ne peut pas être défini, c'est que non-trivial d'initialisation serait nécessaire (constructeur doit être appelé).

OriginalL'auteur Alper

Je vais résumer les règles sur l'initialisation de classe sur le C++98 vs C++11:

Le code suivant est illégal en C++03, mais fonctionne exactement comme vous l'attendez en C++11. En C++11, vous pouvez considérer que les initialiseurs d'être injecté dans chacun des constructeurs de la nacelle, à moins que le constructeur définit une autre valeur.

struct POD {
    int integer = 42; 
    float floating_point = 4.5f;
    std::string character_string = "Hello";
};

Rendre les champs mutables les membres statiques casser le code dans les deux normes, c'est parce que le static assure qu'une copie de la variable et, par conséquent, de déclarer les membres dans un exactement un fichier, tout comme nous le ferions avec des variables globales à l'aide de la visée à l'aide du mot-clé extern.

//This does not work
struct POD {
    static int integer = 42;
    static float floating_point = 4.5f;
    static std::string character_string = "Hello";
};

int   POD::integer = 42;
float POD::floating_point = 4.5f;
std::string POD::character_string = "Hello";

//This works
struct POD {
    static int integer;
    static float floating_point;
    static std::string character_string;
};

int   POD::integer = 42;
float POD::floating_point = 4.3f;
std::string POD::character_string = "hello";

Si nous essayons de les faire, const membres statiques d'un nouvel ensemble de règles surviennent:

struct POD {
    static const int integer = 42;               //Always works
    static constexpr float floating_point = 4.5f;    //Works in C++11 only.
    static const std::string character_string = "Hello"; //Does not work.
    constexpr static const std::string character_string = "Hello"; //Does not work (last checked in C++11)

    //Like some others have also mentioned, this works.
    static const std::string character_string;
};

//In a sourcefile:
const std::string POD::character_string = "Hello";

Donc, à partir de C++11, il est permis de faire constantes statiques de non-entier trivial types de variable. Les chaînes malheureusement ne correspond pas au projet de loi, donc on ne peut initialiser constexpr std::les chaînes de caractères, même en C++11.

Tout n'est pas perdu, cependant, comme une réponse à ce post mentionne, vous pouvez créer une chaîne de fonctions de classe comme une chaîne littérale.

NB! Notez que vous c'est la métaprogrammation à son meilleur, si l'objet est déclaré comme constexpr statique à l'intérieur d'une classe, puis, dès que vous entrez au moment de l'exécution, l'objet est nulle part pour être trouvée. Je n'ai pas compris pourquoi, n'hésitez pas à commenter.

//literal string class, adapted from: http://en.cppreference.com/w/cpp/language/constexpr
class conststr {
const char * p;
std::size_t sz; 
public:
template<std::size_t N>
constexpr conststr(const char(&a)[N]) : p(a), sz(N-1) {}
//constexpr functions signal errors by throwing exceptions from operator ?:
constexpr char operator[](std::size_t n) const {
return n < sz ? p[n] : throw std::out_of_range("");
}   
constexpr std::size_t size() const { return sz; }
constexpr bool operator==(conststr rhs) {
return compare(rhs) == 0;
}   
constexpr int compare(conststr rhs, int pos = 0) {
return ( this->size() < rhs.size() ? -1 :
( this->size() > rhs.size() ? 1 : 
( pos == this->size()  ? 0 : 
( (*this)[pos] < rhs[pos] ? -1 :
( (*this)[pos] > rhs[pos] ? 1 : 
compare(rhs, pos+1)
)   
)   
)   
)   
);  
}   
constexpr const char * c_str() const { return p; }
};

Maintenant, vous pouvez déclarer une conststr directement en vous classe:

struct POD {
static const int integer = 42;               //Always works
static constexpr float floating_point = 4.5f;          //Works in C++11 only.
static constexpr conststr character_string = "Hello"; //C++11 only, must be declared.
};  
int main() {
POD pod; 
//Demonstrating properties.
constexpr conststr val = "Hello";
static_assert(val == "Hello", "Ok, you don't see this.");
static_assert(POD::character_string == val, "Ok");
//static_assert(POD::character_string == "Hi", "Not ok.");
//static_assert(POD::character_string == "hello", "Not ok.");
constexpr int compare = val.compare("Hello");
cout << compare << endl;
const char * ch = val.c_str(); //OK, val.c_str() is substituted at compile time.
cout << ch << endl;   //OK
cout << val.c_str() << endl; //Ok
//Now a tricky one, I haven't figured out why this one does not work:
//cout << POD::character_string.c_str() << endl; //This fails linking.
//This works just fine.
constexpr conststr temp = POD::character_string;
cout << temp.c_str() << endl;
} 

OriginalL'auteur Stian V. Svedenborg