C++ (异或字符串) : "recursive type or function dependency context too complex"

Question

我正在尝试使用以下 XORString 模板/宏在编译时加密字符串文字:

#pragma once

#include <string>

namespace utils {

    template <int X> struct EnsureCompileTime {
        enum : int {
            Value = X
        };
    };

    //Use Compile-Time as seed
#define compile_seed (  (__TIME__[7] - '0') * 1  + (__TIME__[6] - '0') * 10     +   \
                            (__TIME__[4] - '0') * 60   + (__TIME__[3] - '0') * 600  +   \
                            (__TIME__[1] - '0') * 3600 + (__TIME__[0] - '0') * 36000    )

    constexpr int LinearCongruentGenerator(int Rounds) {
        return 1013904223 + 1664525 * ((Rounds > 0) ? LinearCongruentGenerator(Rounds - 1) : compile_seed & 0xFFFFFFFF);
    }

#define Random() EnsureCompileTime<LinearCongruentGenerator(10)>::Value //10 Rounds
#define RandomNumber(Min, Max) (Min + (Random() % (Max - Min + 1)))

    template <int... Pack> struct IndexList {};

    template <typename IndexList, int Right> struct Append;
    template <int... Left, int Right> struct Append<IndexList<Left...>, Right> {
        typedef IndexList<Left..., Right> Result;
    };

    template <int N> struct ConstructIndexList {
        typedef typename Append<typename ConstructIndexList<N - 1>::Result, N - 1>::Result Result;
    };

    template <> struct ConstructIndexList<0> {
        typedef IndexList<> Result;
    };

    template <typename Char, typename IndexList> class XorStringT;
    template <typename Char, int... Index> class XorStringT<Char, IndexList<Index...> > {

    private:
        Char Value[sizeof...(Index)+1];

        static const Char XORKEY = static_cast<Char>(RandomNumber(0, 0xFFFF));

        template <typename Char>
        constexpr Char EncryptCharacterT(const Char Character, int Index) {
            return Character ^ (XORKEY + Index);
        }

    public:
        __forceinline constexpr XorStringT(const Char* const String)
            : Value{ EncryptCharacterT(String[Index], Index)... } {}

        const Char *decrypt() {
            for (int t = 0; t < sizeof...(Index); t++) {
                Value[t] = Value[t] ^ (XORKEY + t);
            }

            Value[sizeof...(Index)] = static_cast<Char>(0);

            return Value;
        }

        const Char *get() {
            return Value;
        }
    };

#define XORSTR( String ) ( utils::XorStringT<char, utils::ConstructIndexList<sizeof( String ) - 1>::Result>( String ).decrypt() )
}

代码不是我的，我对c++模板或元编程知之甚少。该代码在小字符串(<250 个字符)上按预期工作，但是，我需要让它在长字符串(数千个字符)上也能工作。

当我在具有数千个字符的字符串文字上使用 XORSTR 宏时，我在编译期间收到“递归类型或函数依赖上下文太复杂”错误。

我已经尝试弄清楚代码到底做了什么，看起来这些行从输入字符串递归地构造了某种编译时数组(？)，ConstructIndexList 行是是什么产生了错误:

template <typename IndexList, int Right> struct Append;
    template <int... Left, int Right> struct Append<IndexList<Left...>, Right> {
        typedef IndexList<Left..., Right> Result;
    };

    template <int N> struct ConstructIndexList {
        typedef typename Append<typename ConstructIndexList<N - 1>::Result, N - 1>::Result Result;
    };

由于我对模板知之甚少，所以我不确定如何解决这个问题。

我的一个想法是传递原始文字的宏子字符串，然后将它们连接起来(以程序方式，而不是手动)，但是......我不知道如何在上进行编译时子字符串/连接操作文字，也许这是不可能的。

另一个想法是简单地手动拆分我的文字，将拆分后的字符串分别传递给 XORSTR，然后手动连接结果，但这在我的代码中造成了很多困惑......考虑到我需要对数万个字符运行 XORSTR，并且当 >~250 个字符传递给它时会弹出错误。

任何其他想法将不胜感激......或者如果有人有另一个编译时字符串混淆实现可以采用任意长度的字符串文字......那就太好了!

Answer 1

如果我没记错的话，你的ConstructIndexList (大致)制作std::make_integer_sequence的作品(从 C++14 开始可用)。

所以我想你可以写

template <typename>
struct cilH;

template <int ... Is>
struct cilH<std::integer_sequence<int, Is...>>
 { using type = IndexList<Is...>; };

template <int N>
struct ConstructIndexList
 { using Result = typename cilH<decltype(std::make_integer_sequence<int, N>{})>::type; };

避免递归瓶颈。

(但请记住 #include <utility>)。

但是，我想，ConstructIndexList如果使用 std::size_t 类型，则完全可以避免, 而不是 int , 为你的索引。

我想你的代码可以简化如下

#include <array>
#include <string>
#include <utility>
#include <iostream>

namespace utils
 {
   constexpr std::size_t compSeed {
          (__TIME__[7] - '0') * 1U
        + (__TIME__[6] - '0') * 10U
        + (__TIME__[4] - '0') * 60U
        + (__TIME__[3] - '0') * 600U
        + (__TIME__[1] - '0') * 3600U
        + (__TIME__[0] - '0') * 36000U };

   constexpr std::size_t linCongrGen (std::size_t rou)
    { return 1013904223U + 1664525U * ((rou > 0U)
        ? linCongrGen(rou - 1U)
        : compSeed & 0xFFFFFFFFU); }

   constexpr std::size_t randNumber (std::size_t mn, std::size_t mx)
    { return mn + (linCongrGen(10U) % (mx - mn + 1U)); }

   template <typename, typename>
   class XorStringT;

   template <typename Char, std::size_t ... Is>
   class XorStringT<Char, std::index_sequence<Is...>>
    {
      private:
         Char Value[sizeof...(Is)+1U];

         static constexpr Char XORKEY = Char(randNumber(0, 0xFFFF));

      public:
         constexpr XorStringT (Char const * const String)
            : Value{ Char(String[Is] ^ (XORKEY + Is))... }
          { }

         constexpr std::array<Char, sizeof...(Is)+1U> decrypt () const
          { return { { Char(Value[Is] ^ (XORKEY + Is)) ..., Char(0) } }; }

         Char const * get () const
          { return Value; }
    };
 }

template <typename T, std::size_t N>
constexpr auto xorStr (T (&s)[N])
 { return utils::XorStringT<T,
      decltype(std::make_index_sequence<N - 1U>{})>( s ); }

int main()
 {
   constexpr auto xst = xorStr("secrettext");

   std::cout << xst.get() << std::endl;
   std::cout << xst.decrypt().data() << std::endl;
 }