À l'aide de “constexpr” pour utiliser la chaîne de caractères littérale pour le paramètre de modèle

J'ai écrit un code de jeter const char* à int en utilisant constexpr et donc je peux utiliser un const char* comme un argument de modèle. Voici le code:

#include <iostream>
class conststr
{
public:
template<std::size_t N>
constexpr conststr(const char(&STR)[N])
:string(STR), size(N-1)
{}
constexpr conststr(const char* STR, std::size_t N)
:string(STR), size(N)
{}
constexpr char operator[](std::size_t n)
{
return n < size ? string[n] : 0;
}
constexpr std::size_t get_size()
{
return size;
}
constexpr const char* get_string()
{
return string;
}
//This method is related with Fowler–Noll–Vo hash function
constexpr unsigned hash(int n=0, unsigned h=2166136261)
{
return n == size ? h : hash(n+1,(h * 16777619) ^ (string[n]));
}
private:
const char* string;
std::size_t size;
};
//output function that requires a compile-time constant, for testing
template<int N> struct OUT
{
OUT() { std::cout << N << '\n'; }
};
int constexpr operator "" _const(const char* str, size_t sz)
{
return conststr(str,sz).hash();
}
int main()
{
OUT<"A dummy string"_const> out;
OUT<"A very long template parameter as a const char*"_const> out2;
}

Dans cet exemple de code, le type de out est OUT<1494474505> et le type de out2 est OUT<106227495>. La magie derrière ce code est conststr::hash() c'est un constexpr la récursivité qui utilise FNV fonction de Hachage. Et ainsi, il crée intégrante de hachage pour const char* qui, je l'espère, d'un genre unique.

J'ai quelques questions au sujet de cette méthode:

Est-ce une approche sécuritaire à utiliser? Ou cela peut-il être un mal à un usage spécifique?
Pouvez-vous écrire une meilleure fonction de hachage qui crée différentes entier pour chaque chaîne, sans être limité à un nombre de caractères? (dans ma méthode, la durée est assez longue)
Pouvez-vous écrire un code qui, implicitement, jette const char* à int constexpr via conststr et donc nous n'aurons pas besoin esthétiquement laid (et aussi le temps des consommateurs) _const chaîne définie par l'utilisateur littérale? Par exemple OUT<"String"> juridique (et fonte "Chaîne" en entier).

Toute aide sera appréciée, merci beaucoup.

Si ma réponse decide à votre question, pouvez la marquer comme acceptée ? Sinon, vous pouvez commenter (encore une fois)!
Oh, toutes mes excuses, j'oublie toujours de le faire 🙂

InformationsquelleAutor Equalities of polynomials | 2013-04-07

c++c++11 constexpr string-literals templates

13

Bien que votre méthode est très intéressante, il n'est pas vraiment un moyen de passer un littéral de chaîne comme un argument de modèle. En fait, c'est un générateur de modèle argument fondé sur la chaîne littérale, ce qui n'est pas le même: vous ne pouvez pas récupérer string de hashed_string... Ça va à l'encontre l'intérêt de littéraux de chaîne dans les modèles.

MODIFIER : ce qui suit a été droit lorsque la valeur de hachage utilisée est la somme pondérée des lettres, ce qui n'est pas le cas suite à la modification de l'OP.
Vous pouvez également avoir des problèmes avec votre fonction de hachage, comme l'a déclaré mitchnull de réponse. Cela peut être un gros problème avec votre méthode, les collisions. Par exemple:
```
//Both outputs 3721
OUT<"0 silent"_const> out;
OUT<"7 listen"_const> out2;
```
Autant que je sache, vous ne pouvez pas passer une chaîne de caractères littérale dans un modèle argument carrément dans la norme actuelle. Cependant, vous pouvez "faux" il. Voici ce que j'utilise en général:
```
struct string_holder              //
{                                 //All of this can be heavily optimized by
static const char* asString() //the compiler. It is also easy to generate
{                             //with a macro.
return "Hello world!";    //
}                             //
};                                //
```
Ensuite, je passe le "faux littéral de chaîne" à partir d'un argument de type:
```
template<typename str>
struct out
{
out()
{
std::cout << str::asString() << "\n";
}
};
```
EDIT2: vous avez dit dans les commentaires que vous avez utilisé cette distinction entre plusieurs spécialisations d'un modèle de classe. La méthode que vous avez montré est valide, mais vous pouvez aussi utiliser les tags:
```
//tags
struct myTag {};
struct Long {};
struct Float {};
//class template
template<typename tag>
struct Integer
{
//...
};
template<> struct Integer<Long> { /* ... */ };
//use
Integer<Long> ...;  //those are 2
Integer<Float> ...; //different types
```
- Synxis, j'ai édité mon code. Ma fonction de hachage a été un manque de professionnalisme, maintenant c'est à l'aide de Fowler–Noll–Vo fonction de hachage. Je crois que cette fonction n'a pas le même problème. Et je ne pouvais pas comprendre votre premier paragraphe sur la chaîne de hashed_string?
- Vous n'avez pas passer la chaîne à OUT, mais le résultat de hash(). Je ne pense pas que vous pouvez transformer cette valeur en chaîne... Donc, vous ne pouvez pas avoir OUT en sortie de la chaîne de caractères que vous avez écrit entre parenthèses.
- Oh, je vois. En fait ce n'est pas un problème pour moi (bien sûr, votre point est valide) parce que je veux faire des modèles qui fonctionnent comme ceci: disons que nous avons un modèle nommé Entier<>, Integer<"long"> sera quelque chose de différent que Entier<"court"> et je me spécialise mon template à se comporter de la sorte.
- Ok, si c'est ce que vous voulez (mais tout de même un bon point 😉 ). Sont tels chaîne "id" ("long", "court", etc...) en un nombre fixe (finis, comme 10 à 20 différents ids) ?
- En fait oui, et je crois qu'ils devraient être finis parce que je spécialiser chacun de ces modèles manuellement. Je peux utiliser Integer<1> (qui symbolise Entier<"court"> disons), et Entier<2> (qui symbolise Entier<"long"> disons), mais ne pensez-vous pas que l'utilisation de littéraux de chaîne sont esthétiquement mieux et plus facile à lire. On peut oublier ce Integer<1>, mais Integer<"court"> est auto-explicatif.
- Vous pouvez utiliser des balises. Je vais mettre ça dans ma réponse.
- Ouais merci pour le rappel de cette méthode trop. J'ai une fois considéré comme quelque chose de similaire, mais n'a pas écrit un code car depuis que je suis en utilisant l'espace de noms, des étiquettes de noms deviennent longues. Par exemple, disons que je suis en train d'écrire mon code dans "nmsp" espace de noms, l'utilisateur doit écrire nmsp::Integer<nmsp::Long>, ce qui est presque la même (en termes de longueur) avec nmsp::Integer<"long"_const>, et je n'ai pas l'esprit à l'aide de C++11, parce que mon code ne fonctionne pas sans le C++11, de toute façon.
- Bon point. Je préfère les balises, parce que c'est plus "esthétique" que la version littérale, mais ce choix est à vous. Vous pouvez également choisir un autre nom, par exemple _tag.
InformationsquelleAutor Synxis
6

Voici le modèle que j'utilise pour le modèle const paramètres de la chaîne.
class F { static constexpr const char conststr[]= "some const string"; TemplateObject<conststr> instance; };

voir :
https://stackoverflow.com/a/18031951/782168

InformationsquelleAutor h4ck3rm1k3

Vous devez vous connecter pour publier un commentaire.