En passant const char* comme argument de modèle

Pourquoi ne pouvez pas vous passer des chaînes de caractères littérales ici? J'ai fait le travail avec une très légère solution de contournement.

template<const char* ptr> struct lols {
    lols() : i(ptr) {}
    std::string i;
};
class file {
public:
    static const char arg[];
};
decltype(file::arg) file::arg = __FILE__;
//Getting the right type declaration for this was irritating, so I C++0xed it.

int main() {
    //lols<__FILE__> hi; 
    //Error: A template argument may not reference a non-external entity
    lols<file::arg> hi; //Perfectly legal
    std::cout << hi.i;
    std::cin.ignore();
    std::cin.get();
}
  • const char file::arg[] = __FILE__; Cela devrait vous permettre de redescendre à C++03 :).
  • J'ai essayé aussi. Compilateur a jeté erreur.
  • Impair. g++ compile très bien (avec -pédant).
  • Irritant, j'ai toujours pensé que c'était impossible. Maintenant que je l'ai, je n'arrive pas à lui faire faire quelque chose d'intéressant ou d'utile.
  • Qu'en essayant const char *const ptr pour l'argument de modèle à la place? Après tout, c'est un littéral.
  • Noter que si, à portée espace de noms, vous aurez besoin extern const char arg[] = __FILE__; de donner la matrice de liaison externe (const objets ont une liaison interne par défaut).
  • Pour ceux qui sont intéressés, David a écrit, comment le faire ici — cpp-next.com/archive/2012/10/...

InformationsquelleAutor Puppy | 2010-09-22
  1. 16

    Parce que ce ne serait pas un utilitaire utile. Depuis qu'ils ne sont pas autorisés forme d'un argument de modèle, il ne fonctionne pas.

    Supposons qu'ils travaillent. Parce qu'ils ne sont pas tenus d'avoir la même adresse pour la même valeur, vous obtiendrez les différentes instanciations même si vous avez le même littéral de chaîne de valeur dans votre code. 

    lols<"A"> n;

//might fail because a different object address is passed as argument!
lols<"A"> n1 = n;

    Vous pourriez écrire un plugin pour votre éditeur de texte qui remplace une chaîne de caractères en une liste séparée par des virgules de chaînes de caractères et à l'arrière. Avec variadic templates, vous pourrait "résoudre" le problème de cette façon, d'une certaine façon.

    • Juste pose la question de savoir pourquoi ils n'ont pas juste de leur donner la même adresse.
    • parce que la chaîne littérale "A" peut être immédiate dans certains contextes et pas une adresse à tout?
    • Je sais, ça fait un moment, mais pourriez-vous développer ce que? Je suis en quelque sorte également intéressé par l'explication.
    • de l'autre alors. Étant donné que l'argument de modèle doit avoir son adresse, le compilateur aurait besoin de fournir une adresse unique pour la chaîne littérale "Un". Il serait inutile de restriction pour le compilateur d'avoir à le faire. La lettre "A" peut être une constante dans la mémoire quelque part (et avoir une adresse), mais le compilateur peut avoir plusieurs copies l'adresse ne serait pas unique, ou littérale "Une" pourrait être la "immédiat" de l'opérande d'une machine d'instruction en code bit.ly/17HySsu et, par conséquent, ne pas être dans la mémoire des données de n'importe où et n'est donc pas une adresse à tous.
    • C'est tout à fait erronée. La langue exige déjà que le compilateur de fusion globales dans de nombreux contextes (par exemple les fonctions inline). Il n'y aurait rien de plus ou de moins fatigante sur les forçant à la piscine littéraux de chaîne. Comme pour immédiates, un littéral de chaîne doit avoir programme-durée de stockage, de sorte qu'il serait illégal de le faire déjà pour stocker le contenu d'une chaîne de caractères littérale dans l'immédiat.
    • Je ne vois pas pourquoi extern est ici nécessaire. Si le littéral de chaîne est définie comme static const char * foo = "foo"; et il est utilisé uniquement à l'intérieur de la même module, pourquoi ne pas l'utiliser comme un modèle de valeur de l'argument, étant donné que le modèle résultant de l'instance ne peut être utilisé à l'intérieur du module? Pourquoi foopas une constante de compilation? Ne fait pas de sens pour moi que ce soit. Aussi les commentaires sur le fait que c'est "utile" ne parviennent pas à me convaincre. Il peut être utile dans certains scénarios.
    • si elles vont permettre aux chaînes de caractères comme argument de modèle, de l'OMI, ils ne devraient pas utiliser l'adresse est unique solution de contournement mais prend nullement en charge en mode natif en passant d'une chaîne de valeur, peut-être comme une petite classe définie par l'utilisateur qui contient un char tableau ou d'un variadic char modèle fait par l'utilisateur défini littérale de l'opérateur modèles, au lieu de vous embêter avec les adresses.
    • J'ai trouvé cette question quand j'ai voulu générer un modèle personnalisé d'exception qui prend __LINE__ comme son modèle. Je ne veux pas qu'il soit la copie constructible ou quoi que ce soit, j'ai juste besoin d'un moyen d'ajouter une corde à mon exceptions sans réellement la construction d'une chaîne de caractères à chaque case.

    InformationsquelleAutor Johannes Schaub - litb
  2. 6

    C'est possible, mais l'argument de modèle doit avoir une liaison externe, ce qui empêche l'utilisation des chaînes de caractères littérales et atténue l'utilité de le faire.

    Un exemple que j'ai est:

    template<const char* name, const char* def_value=empty_>
struct env : public std::string
{
    env()
    {
        const char* p = std::getenv(name);
        assign(p ? p : def_value);
    }
};

extern const char empty_[] = "";

std::string test = env<empty_>();
    • ...sauf que vous n'êtes pas censé hériter de juste au sujet de quoi que ce soit dans namespace std
    InformationsquelleAutor Nathan Ernst
  3. 5

    C'est comment je le fais. Fait beaucoup plus de sens pour moi:

    struct MyString { static const std::string val; }
const std::string MyString::val = "this is your string";

template<typename T>
void func()
{
  std::cout << T::val << std::endl;
}

void main()
{
  func<MyString>();
}
    InformationsquelleAutor Michael
  4. 1

    Cela fonctionne pour les classes et, de l'OMI, est utile. La mise en œuvre est rapide et sale, mais peut être facilement fait en nettoyant:

    #include <stdio.h>
#include <string.h>

struct TextTag { const char *text; };

template <const TextTag &TRUE, const TextTag &FALSE>
struct TextTaggedBool
{
  const char *GetAsText() const { return m_value ? TRUE.text: FALSE.text; }
  void SetByText(const char *s) { m_value = !strcmp(s, TRUE.text); }
  bool m_value;
};

class Foo
{
public:
    void method()
    {
        m_tbool.SetByText("True!");  printf("%s\n", m_tbool.GetAsText());
        m_tbool.SetByText("False!"); printf("%s\n", m_tbool.GetAsText());
        m_tbool.m_value = true;  printf("%s\n", m_tbool.GetAsText());
        m_tbool.m_value = false; printf("%s\n", m_tbool.GetAsText());
    }

private:
    static constexpr TextTag TrueTag = { "True!" };
    static constexpr TextTag FalseTag = { "False!" };
    TextTaggedBool<TrueTag, FalseTag> m_tbool;
};

void main() { Foo().method(); }

    De sortie:

    Vrai!
    Faux!
    Vrai!
    Faux!

    InformationsquelleAutor Ben Earhart
  5. 0

    Bonne question, j'ai pensé jeter mon chapeau dans l'anneau... je pense que vous pouvez passer des pointeurs vers des variables statiques non-gabarit de type d'arguments. À partir de C++20 on dirait qu'il ne sera pas un problème... Jusqu'à alors, voici quelques bon marché macro pour le faire fonctionner.

    template <const char *Name, typename T>
struct TaggedValue {
  static constexpr char const *name{Name};
  T value;
  friend ostream &operator<<(ostream &o, const TaggedValue &a) {
    return o << a.name << " = " << a.value;
  }
};

#define ST(name, type)\
  const char ST_name_##name[]{#name};\
  using name = TaggedValue<ST_name_##name,type>;

ST(Foo, int);
ST(Bar, int);
ST(Bax, string);

int main() {
  cout << Foo{3} << endl;
  cout << Bar{5} << endl;
  cout << Bax{"somthing"} << endl;
}
    InformationsquelleAutor Nathan Chappell