Usando "constexpr" para usar el literal de cadena para el parámetro de plantilla

He escrito algún código para convertir const char* a int usando constexpr y por lo tanto puedo usar un const char* como argumento de plantilla. Aquí está el código:

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

En este código de ejemplo, type of out es OUT<1494474505> y type of out2 es OUT<106227495>. La magia detrás de este código es conststr::hash() es una recursión constexpr que usa la función Hash FNV. Y por lo tanto crea un hash integral para const char* que es, con suerte, único.

Tengo algunas preguntas sobre esto método:

1. ¿Es este un enfoque seguro de usar? ¿O puede este enfoque ser un mal en un uso específico?
2. ¿Puede escribir una mejor función hash que cree diferentes enteros para cada cadena sin limitarse a un número de caracteres? (en mi método, la longitud es lo suficientemente larga)
3. ¿Puedes escribir un código que implemente const char* a int constexpr a través de conststr y por lo tanto no necesitaremos un literal de cadena definido por el usuario estéticamente feo (y también consumidor de tiempo) _const? Por ejemplo OUT<"String"> será legal (y convertir "String" a integer).

Cualquier ayuda será apreciada, muchas gracias.