Manipulation 'String' au moment de la compilation avec des modèles variadiques

Question

Salut à tous, J'essaye actuellement d'écrire un chiffrement de chaîne à la compilation (en utilisant les mots 'string' et 'encryption' assez librement) lib.

Ce que j'est jusqu'à présent comme suit:

// Cacluate narrow string length at compile-time 
template <char... ArgsT> 
struct CountArgs 
{ 
template <char... ArgsInnerT> struct Counter; 

template <char Cur, char... Tail> 
struct Counter<Cur, Tail...> 
{ 
    static unsigned long const Value = Counter<Tail...>::Value + 1; 
}; 

template <char Cur> 
struct Counter<Cur> 
{ 
    static unsigned long const Value = 1; 
}; 

static unsigned long const Value = Counter<ArgsT...>::Value; 
}; 

// 'Encrypt' narrow string at compile-time 
template <char... Chars> 
struct EncryptCharsA 
{ 
static const char Value[CountArgs<Chars...>::Value + 1]; 
}; 

template<char... Chars> 
char const EncryptCharsA<Chars...>::Value[CountArgs<Chars...>::Value + 1] = 
{ 
Chars... 
}; 

Cependant je ne peux pas comprendre comment effectuer des opérations sur les personnages que je les développer dans le tableau statique. Je voudrais juste exécuter une opération simple sur chaque caractère (par exemple '(((c^0x12)^0x55) + 1)' où c est le caractère).

Une poussée dans la bonne direction serait grandement appréciée.

Merci à tous.

Answer 1

Si vous voulez juste faire fonctionner sur un caractère à la fois il est facile:

template<char c> struct add_three { 
    enum { value = c+3 }; 
}; 

template <char... Chars> struct EncryptCharsA { 
    static const char value[sizeof...(Chars) + 1]; 
}; 

template<char... Chars> 
char const EncryptCharsA<Chars...>::value[sizeof...(Chars) + 1] = { 
    add_three<Chars>::value... 
}; 

int main() { 
    std::cout << EncryptCharsA<'A','B','C'>::value << std::endl; 
    // prints "DEF" 
} 

Notez que CountArgs est redondant (c'est ce que sizeof... est pour) et que celui-ci utilise element-wise transformation of the elements in a parameter-pack.

---

Pour rendre la transformation dépendante des résultats précédents, une option serait de consommer les caractères récursive, un à la fois, et construire progressivement un nouveau modèle de celui:

template<char... P> struct StringBuilder { 
    template<char C> struct add_char { 
     typedef StringBuilder<P..., C> type; 
    }; 

    static const char value[sizeof...(P)+1]; 
}; 

template<char... P> const char StringBuilder<P...>::value[sizeof...(P)+1] = { 
    P... 
}; 

template<class B, char...> struct EncryptImpl; 

template<class B, char Seed, char Head, char... Tail> 
struct EncryptImpl<B, Seed, Head, Tail...> { 
    static const char next = Head + Seed; // or whatever 
    typedef typename EncryptImpl< 
     typename B::template add_char<next>::type, 
     next, Tail... 
    >::type type; 
}; 

template<class B, char Seed> struct EncryptImpl<B, Seed> { 
    typedef B type; 
}; 

template<char... P> struct Encrypt { 
    typedef typename EncryptImpl<StringBuilder<>, 0, P...>::type type; 
}; 

Answer 2

Si je comprends ce que vous voulez faire correctement (en fait créer un tableau au moment de la compilation) Je pense que les modèles variés ne suffisent pas et vous devrez attendre constexpr.

Si toutefois vous n'avez pas besoin d'un tableau réel et peut compromettre la place sur l'utilisation de quelque chose de semblable à l » get<I>tuple alors il est possible (vous pouvez construire un tableau char lors de l'exécution).