meilleure alternative à l'initialisation en définition des membres de classe statiques? (pour les mots-clés SVN)

Question

Je stocke des littéraux de mots-clés SVN développés pour les fichiers .cpp dans les membres de la classe 'static char const * const' et je veux stocker les descriptions .h aussi similairement que possible. En bref, je dois garantir l'instanciation unique d'un membre statique (vraisemblablement dans un fichier .cpp) vers un littéral non entier auto-généré résidant dans un fichier .h potentiellement partagé. Malheureusement, le langage ne tente pas de résoudre plusieurs instanciations résultant d'affectations effectuées en dehors des définitions de classe et interdit explicitement les inits non entiers à l'intérieur des définitions de classe. Ma meilleure tentative (en utilisant des classes internes d'emballage statique) n'est pas trop sale, mais j'aimerais vraiment faire mieux. Est-ce que quelqu'un a un moyen de modéliser l'enveloppe ci-dessous ou d'avoir une approche tout à fait supérieure?

// Foo.h: class with .h/.cpp SVN info stored and logged statically 
class Foo { 
    static Logger  const verLog; 
    struct hInfoWrap; 
public: 
    static hInfoWrap const hInfo; 
    static char const *const cInfo; 
}; 

// Would like to eliminate this per-class boilerplate. 
struct Foo::hInfoWrap { 
    hInfoWrapper() : text("$Id$") { } 
    char const *const text; 
}; 

...

// Foo.cpp: static inits called here 
Foo::hInfoWrap const Foo::hInfo; 
char const  *const Foo::cInfo = "$Id$"; 
Logger   const Foo::verLog(Foo::cInfo, Foo::hInfo.text); 

...

// Helper.h: output on construction, with no subsequent activity or stored fields 
class Logger { 
    Logger(char const *info1, char const *info2) { 
    cout << info0 << endl << info1 << endl; 
    } 
}; 

est-il un moyen de contourner le problème d'adresse de liaison statique pour Templating la classe hInfoWrap sur les littéraux de chaîne? Les pointeurs de char externe attribués à des définitions de classe externes sont linguistiquement valides mais échouent essentiellement de la même manière que les initialisations directes de membres. Je comprends pourquoi le langage contourne l'ensemble du problème de résolution, mais ce serait très pratique si un qualificateur de membre externe inversé était fourni, où le code de définition était visible dans les définitions de classe à tout appelant mais seulement invoqué au moment d'un seul déclaration ailleurs.

Quoi qu'il en soit, je m'égare. Quelle est la meilleure solution pour la langue que nous avons, modèle ou autre? Merci!

Answer 1

probablement, avec une fonction statique?

// Foo.h: 
class Foo { 
    static Logger  const verLog; 
    static char const*const getHInfo() { return "$Id$"; } 
public: 
    static char const *const cInfo; 
}; 

// Foo.cpp: static inits called here 
char const  *const Foo::cInfo = "$Id$"; 
Logger   const Foo::verLog(Foo::cInfo, Foo::getHInfo()); 

Answer 2

Peut-être que vous pourriez faire quelque chose avec des macros.

// Foo.h 
#define FOO_HINFO "$Id$" 

...

// Foo.cpp 
char const  *const Foo::hInfo = FOO_HINFO; 

J'évite généralement des macros, mais dans ce cas, il pourrait être la solution la plus propre.