idiome correct pour les constantes de chaîne de caractères (pas std :: string) en C++

Question

Il ya quelque temps, j'ai demandé des constantes std :: string correct idiom for std::string constants?. Ce que j'en ai retiré était et non pour utiliser les constantes std :: string mais utiliser des constantes de chaîne de caractères. Alors quel est le meilleur langage pour que

#define FOO "foo" 

const char * const FOO = "foo"; 

const char FOO[] = "foo"; 

caractéristiques Souhaitable

• get longueur au moment de la compilation. 1 & 3 mais pas 2 (sizeof ne fonctionne pas sur 2)
• peut être inclus dans .h sans le linker se plaindre. tous (je pense)
• pas de copies multiples en .o, en sortie liée . dépend du compilateur (probablement)

Il semble donc que # 3 est mieux, mais Scott Meyers dit utiliser # 2 (efficace C++ item # 1)

résumé des réponses

1. utilisation joyeux modèle de code compliqué
2. utilisation # 3

Le code du modèle se sent comme surpuissant. Donc pour l'instant je vais aveC# 3;

Mais je vais ruminer sur le code du modèle, la version macroisée le rend OKish; mais je n'aime pas le fait que ce n'est pas portable (qui sait, peut-être que gcc décidera que c'est faux aussi)

Answer 1

Vos caractéristiques souhaitées sont contradictoires.

1. Longueur au moment de la compilation
2. défini dans le fichier d'en-tête
3. copie unique dans toutes les unités de compilation

Pour obtenir (1) et (2), vous devez déclarer la variable comme static ou mettez-le dans un espace de noms sans nom. Cependant, cela provoquera une définition dans chaque unité de compilation, ce qui va à l'encontre de (3). Pour obtenir (2) et (3), vous devez déclarer la variable extern, mais vous n'obtiendrez pas (1). Pour obtenir (2) et (3), vous devez déclarer la variable extern.

Maintenant, si votre éditeur de liens est intelligent, il peut optimiser loin les copies multiples, mais je ne suis pas sûr si la norme le permet ...

Je recommande la syntaxe const char FOO[] = "foo"; déclaré dans un espace de noms sans nom ou static s'il doit être trouvé dans un espace de noms spécifique. Si la chaîne est très grande, alors je vais pour un extern.

Answer 2

Voici comment je le vois. Je n'utiliserais aucun de ceux-ci tels quels. D'abord, je suis incliné par # 2, mais, tenez compte du fait que vous devez déclarer la variable comme extern dans le .h, et en sélectionner quelques-uns.cpp pour stocker réellement la chaîne:

// .h 
extern const char*const STR; 

// .cpp 
const char*const STR = "abc"; 

Le seul inconvénient, ne pas avoir la longueur lors de l'exécution, ne me semble pas une vraie raison de passer à autre option. Si vous avez plusieurs chaînes, vous pouvez toujours avoir un ensemble de constantes entières (ou #define s) pour spécifier la longueur de chaque chaîne, par exemple STR_LEN. Si vous en avez beaucoup, vous ne les écrirez pas de toute façon, et vous pourrez alors générer automatiquement les constantes ..._LEN en même temps.

Answer 3

Pour les fonctionnalités que vous voulez, ...

• longueur get au moment de la compilation,
• peuvent être inclus dans .h sans linker se plaindre tous,
• pas plusieurs copies en .o, en sortie reliée,

... vous pouvez utiliser le langage constant basé sur un modèle, comme

template< class Dummy > 
struct Foo_ 
{ 
    static char const s[]; 
}; 

template< class Dummy > 
char const Foo_<Dummy>::s[] = "Blah blah"; 

typedef Foo_<void> Foo; // Now you can refer to Foo:s 


#include <iostream> 
using namespace std; 
int main() 
{ 
    cout << sizeof(Foo::s) << " bytes: \"" << Foo::s << "\"\n"; 
} 

Vous pouvez envelopper la génération dans une macro. Cependant, autant que je sache, la seule utilité pratique est de supporter le code char/wchar_t-agnostic, et pour cela la douleur peut être plus grande que le gain.

EDIT:
versions MSVC 7.1 à travers 10.0 n'accepte pas correctement la sizeof. Ce qui suit est une solution de contournement qui compile bien avec g ++ 4.4.1, Comeau Online 4.3.10.1, MSVC 7.1 et MSVC 10.0.

#include <stddef.h> 

typedef ptrdiff_t Size; 

// Substitute a more general countOf 
template< Size n > 
struct SizedBuf { char sizer[n]; }; 

template< class Type, Size n > 
SizedBuf<n> countOf_(Type (&)[n]) { return n; } 

#define COUNT_OF(array) sizeof(countOf_(array).sizer) 

#define DEF_STRING(name, value)        \ 
    template<class>           \ 
    struct name##_constant_          \ 
    {               \ 
     static char const str[];        \ 
     static Size const length = COUNT_OF(value) - 1; \ 
    };               \ 
                   \ 
    template< class Type >          \ 
    char const name##_constant_<Type>::str[] = value;   \ 
                   \ 
    template< class Type >          \ 
    Size const name##_constant_<Type>::length;    \ 
                   \ 
    typedef name##_constant_<void> name; 


DEF_STRING(a, "Argh, MSVC!") 
DEF_STRING(b, "Blah blah") 
DEF_STRING(c, "Currently there's no 'inline' for data in C++.") 


#include <iostream> 

template< char const* s > 
void foo() { std::cout << "foo() says: " << s << std::endl; } 

int main() 
{ 
    using namespace std; 

    int const x[a::length] = {}; // Showing off compile time constant. 
    foo<a::str>();     // Showing off external linkage. 

    cout << a::length << " characters: \"" << a::str << "\"." << endl; 
} 

Vive & HTH.,

Answer 4

Je pense que vous avez pris une mauvaise idée loin de votre question précédente.
Les chaînes ont tendance à être clairsemées et ne sont pas bonnes pour la recherche, utilisez plutôt des chiffres.

Vous ne semblez toujours pas obtenir la différence entre déclarer dans un fichier .h et définir le stockage dans un fichier .cpp, évitant ainsi plusieurs copies. Même si vous aviez plusieurs copies (avec des noms de constante différents), vous auriez toujours le problème que vous avez mentionné dans votre question précédente.

a un défaut fatal. Je ne peux pas avoir le code de niveau du module statique qui utilise ces chaînes car ils pourraient ne pas avoir été construit encore

La seule façon d'éviter cela est d'amener les constantes dans le même champ avec ce que vous avez actuellement au niveau du module statique.

Mettez tous les éléments liés dans une classe!

Answer 5

Ceci est juste le macro'd de réponse Alf:

#include <iostream> 

#define string_constant(pName, pLiteral)     \ 
     template <typename = void>       \ 
     struct pName##_detail        \ 
     {             \ 
      static const char value[];      \ 
     };             \ 
                  \ 
     template <typename T>        \ 
     const char pName##_detail<T>::value[] = pLiteral; \ 
                  \ 
     typedef pName##_detail<> pName 

string_constant(my_constant, "this is a literal"); 

int main() 
{ 
    std::cout << my_constant::value << std::endl; 
    std::cout << sizeof my_constant::value << std::endl; 
} 

codepad. Ne semble pas fonctionner dans VS2010. :/