Compilation (préprocesseur) du hachage de la chaîne

Est-il possible de créer une table de hachage de la chaîne au moment de la compilation à l'aide de la C/C++ préprocesseur (ou même un modèle métaprogrammation)?

par exemple UNIQUE_SALT("HelloWord", 3DES);

L'idée est que HelloWorld ne sera pas présent dans le binaire compilé, juste une table de hachage.

Edit: Il y a beaucoup de ces déclarations, réparties sur une grande base de code.

source d'informationauteur AshirusNW

  1. 11

    Avec C++0x, c'est possible que ceux couverts par les réponses dans #1 et #2.

    En C++03 il n'y avait aucun moment de la compilation de la chaîne de traitement. Avec le préprocesseur vous ne pouvez pas séparer la chaîne en jetons, avec des modèles que vous ne pouvez pas accéder à des caractères individuels. Il y a toutefois une discussion sur le spéculé approche à l'aide de C++0x.

    Ce que vous pourriez faire pour C++03 est de faire passer la chaîne de caractère (ce qui est possible à l'aide de multi-chaînes de caractères):

    foo = hash<3DES, str<'a','b','c'> >::result;
//or:
foo = hash<3DES, str<'abc','def'> >::result;

    ... ou tout simplement faire une pré-étape de génération.

  2. 12

    Pourquoi ne pas faire de générer le hachage partie de votre processus de création? Vous pouvez créer un fichier de commandes pour générer le hachage (en supposant que vous avez un programme pour faire une telle chose - si non, écrivez un) et l'ont sortie une directive de préprocesseur quelque chose comme:

    #define MY_HASH 123456789

    à un .h fichier puis obtient #inclus dans votre application.

  3. 6

    Cela peut être fait avec le coup de pouce.MPL, mais il pourrait ne pas être le type de hachage, vous êtes après.

    http://arcticinteractive.com/2009/04/18/compile-time-string-hashing-boost-mpl/

  4. 6

    Alors que ce n'est pas une bonne réponse à la question, voir cette entrée de blog pour un exemple de fonction de hachage pour les chaînes de jusqu'à 256 caractères de mise en œuvre purement comme un C macro:

    http://lolengine.net/blog/2011/12/20/cpp-constant-string-hash

    Voici le code à partir du blog:

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

#define H1(s,i,x)   (x*65599u+(uint8_t)s[(i)<strlen(s)?strlen(s)-1-(i):strlen(s)])
#define H4(s,i,x)   H1(s,i,H1(s,i+1,H1(s,i+2,H1(s,i+3,x))))
#define H16(s,i,x)  H4(s,i,H4(s,i+4,H4(s,i+8,H4(s,i+12,x))))
#define H64(s,i,x)  H16(s,i,H16(s,i+16,H16(s,i+32,H16(s,i+48,x))))
#define H256(s,i,x) H64(s,i,H64(s,i+64,H64(s,i+128,H64(s,i+192,x))))

#define HASH(s)    ((uint32_t)(H256(s,0,0)^(H256(s,0,0)>>16)))

    Si vous savez d'avance que vous allez l'utiliser seulement pour les chaînes statiques vous pouvez remplacer strlen() avec sizeof().

  5. 3

    Même si cela ne peut pas être (relativement) fait avec le préprocesseur, si vous avez utilisé un littéral de chaîne ou elle a déclaré que static const et ne pas créer la pérennité des références à celui-ci le compilateur sera probablement aller de l'avant et de faire tous les calculs pour générer le résultat et omettre la chaîne dans le fichier d'objet si vous compilez avec les optimisations. La partie la plus difficile, c'est que vous ne pouvez pas faire le code pour initialiser un mondial ou variable statique trop compliqué ou le compilateur va dire "hé, vous! Ne savez-vous pas que vous ne pouvez pas utiliser une boucle for en dehors d'une fonction?".

  6. 3

    Je suis tombé sur une solution en utilisant le bon vieux C++ standard (je ne suis pas sûr de quelle version il est considéré comme l', mais disons simplement que cette solution fonctionne dans Visual Studio). Voici le lien: lien.

    Aussi, voici une version courte d'un JSHash de la fonction en utilisant la technique ci-dessus. Ce qui est montré ici, prend en charge jusqu'à 4 caractères, mais vous pouvez en ajouter autant que vous voulez. 

    template<const char A = 0, const char B = 0, const char C = 0, const char D = 0>
struct cHash
{
    template<const char C, size_t hash = 1315423911>
    struct HashCalc
    {
        enum { value = (C == 0) ? hash : hash ^ ((hash << 5) + C + (hash >> 2)) };
    };

    enum { value = HashCalc<D,HashCalc<C,HashCalc<B,HashCalc<A>::value>::value>::value>::value };
};

    Comme l'a noté, parce que c'est un moment de la compilation de hachage, vous pouvez faire quelque chose comme ceci:

    namespace Section
{
    enum Enum
    {
        Player = cHash<'p','l','a','y'>::value
    };
}

    Ce n'est pas la solution la plus élégante, de sorte que j'ai l'intention de faire plus de recherches dans ce domaine, mais comme c'est la seule chose que j'ai appris à travailler dans VisualStudio2010 je suis un peu limité en ce qui concerne mon projet actuel est concerné.

  7. 1

    Réponses affirmant que les chaînes ne peuvent pas être analysés au moment de la compilation sont mauvais. Pointeurs de caractère ne peut pas être analysée au moment de la compilation, mais les littéraux de chaîne ne sont pas des pointeurs de caractère; ils sont des tableaux de caractères dont la longueur est la partie de la type. Il est facile d'oublier que, parce que dans la plupart des cas, il est beaucoup plus utile de les laisser se désintégrer en un char*. Mais ils ne commencent pas de cette façon.

    Ah, mais comment définir une fonction qui prend un caractère de longueur fixe tableau, surtout si on avait plutôt l'utiliser sur des chaînes de caractères de longueur arbitraire? C'est là où argument de modèle déduction est très pratique:

    template<size_t L>
constexpr int hash(const char (&str)[L], int n = L - 1) {
    //hash goes here. You can define recursively as a
    //function of str[n] and hash(str, n-1). Remember to
    //treat 0 as a special case.
}

    Qui devrait vous obtenir a commencé. Évidemment, la valeur de hachage doit être assez simple pour compiler en temps de calcul, mais c'est probablement ok.

  8. 0

    C'est comment je le faire au moment de la compilation de la chaîne de valeur de hachage avec C++0x:

    class StringHash
{
public:
    template <unsigned N, unsigned I>
    struct HashHelper
    {
        constexpr static unsigned Calculate(const char (&str)[N])
        {
            return (HashHelper<N, I - 1>::Calculate(str) ^ (str[I - 1] & 0xFF)) * StringHash::PRIME;
        }
    };

    template <unsigned N>
    struct HashHelper<N, 1>
    {
        constexpr static unsigned Calculate(const char (&str)[N])
        {
            return (StringHash::OFFSET ^ (str[0] & 0xFF)) * StringHash::PRIME;
        }
    };

    template<unsigned N>
    constexpr static unsigned StaticHash(const char (&str)[N])
    {
        return HashHelper<N, N>::Calculate(str);
    }

    static const unsigned OFFSET = 0x01234567;
    static const unsigned PRIME = 0x89ABCDEF;
}

    Utilisation:

    static hash = StringHash::StaticHash("Hello"); //You may even use this expression in `switch case`