Хеширование строки во время компиляции (препроцессор)

С C ++ 0x это возможно, как описано в ответах в # 1 и #2.

В C ++ 03 не было обработки строки времени компиляции. С препроцессором вы не можете разделить строку на токены, с шаблонами вы не можете получить доступ к отдельным символам. Однако было обсуждение предполагаемого подхода с использованием C ++ 0x.

Что вы можете сделать для C ++ 03, так это передать строку посимвольно (возможно с использованием многосимвольных литералов):

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

... или просто сделайте это перед сборкой.

Почему бы не сделать создание хэша частью процесса сборки? Вы можете написать простой командный файл для генерации хэша (при условии, что у вас есть программа для этого - если нет, напишите ее) и вывести директиву препроцессора примерно так:

#define MY_HASH 123456789 

в файл .h, который затем будет # включен в ваше приложение.

Хотя это неправильный ответ на вопрос, см. Эту запись в блоге для примера хеш-функции для строк длиной до 256 символов, реализованной исключительно как макрос C:

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

Вот актуальный код из блога:

#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)))

Если вы заранее знаете, что будете использовать его только для статических строк, вы можете заменить strlen () на sizeof ().

Это можно сделать с помощью Boost.MPL, но это может быть не тот тип хэша, который вам нужен.

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

Даже если это невозможно (разумно) сделать с помощью препроцессора, если вы использовали строковый литерал или объявили его как static const и не создали на него никаких устойчивых ссылок, компилятор, скорее всего, продолжит и выполнит все математические вычисления для генерации result и опустите строку в объектном файле, если вы компилируете с оптимизацией. Самая сложная часть этого заключается в том, что вы не можете сделать код для инициализации глобальной или статической переменной слишком сложным, иначе компилятор скажет: «Эй, ты! Разве вы не знаете, что нельзя использовать цикл for вне функции? ? ".

Я наткнулся на решение, использующее старый добрый стандарт C ++ (я не уверен, какую версию он рассматривает, но давайте просто скажем, что это решение работает в Visual Studio). Вот ссылка: ссылка.

Кроме того, вот короткая версия функции JSHash с использованием описанной выше техники. Показанный здесь поддерживает до 4 символов, хотя вы можете добавить любое количество символов.

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 };
};

Как уже отмечалось, поскольку это хэш времени компиляции, вы можете сделать что-то вроде этого:

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

Это не самое элегантное решение, поэтому я планирую провести дополнительные исследования в этой области, однако, поскольку это единственное, что мне приходилось работать в VisualStudio2010, я немного ограничен в том, что касается моего текущего проекта.

Ответы, утверждающие, что строки не могут быть проанализированы во время компиляции, неверны. Указатели на символы не могут быть проанализированы во время компиляции, но строковые литералы не являются указателями на символы; они представляют собой массивы символов, длина которых является частью типа. Об этом легко забыть, потому что в большинстве случаев гораздо полезнее позволить им превратиться в char *. Но они так не начинаются.

Ах, но как на самом деле определить функцию, которая принимает массив символов фиксированной длины, особенно если мы действительно предпочитаем использовать ее для строк произвольной длины? Вот здесь и пригодится вывод аргументов шаблона:

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.
}

Это должно вас начать. Очевидно, что сам хеш должен быть достаточно простым для вычислений во время компиляции, но это, вероятно, нормально.

Вот как я делаю этот строковый хэш времени компиляции с помощью 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;
}

Использование:

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