Início / coding / Perguntas / 77325081
Accepted
Konvt
Asked: 2023-10-19 23:18:23 +0800 CST

Como concatenar strings repetidamente em tempo de compilação?

  • 772

Escrevi o seguinte código para usar string em tempo de compilação:

template<char... Chars>
struct CnstString {
    template<char... Aped>
    using push_back = CnstString<Chars..., Aped...>;
    constexpr static char value[] = {Chars...};
};

Tudo bem quando eu uso assim:

#include <iostream>
using str = CnstString<'H', 'e', 'l', 'l', 'o', '\0'>;
int main()
{
    std::cout << str << std::endl;
    return 0; // it will output "Hello"
}

O que eu quero fazer é usar uma estrutura de modelo recursiva, unir uma string fornecida pelo código acima em tempo de compilação e anexar a à '\0'matriz no ponto final recursivo.

A razão pela qual escrevi este código é porque quero concatenar a mesma string várias vezes. Obviamente não posso concatenar a mesma string como "Hello""Hello".

A estrutura do modelo recursivo é mostrada abaixo:

template<int N, typename Str>
struct RepeatStr {
    using ret = RepeatStr<N-1, Str>; // this is an error, I don't know how to pass parameters
};
template<typename Str>
struct RepeatStr<-1, Str> {
    using ret = Str:: template push_back<'\0'>;
};

No entanto, descobri que não sabia como acrescentar caracteres a si mesmo usando seus caracteres em Str.

Há algo de errado? Ou é simplesmente impossível fazer em tempo de compilação?

c++

2 respostas

  1. Best Answer

    Se possível, eu mudaria a definição para CnstStringcolocar '\0' apenas emvalue

    template<char... Chars>
struct CnstString {
    constexpr static char value[] = {Chars..., '\0'};
};

    Em seguida, forneça operator +(o que permitiria a expressão Fold (C++ 17) posteriormente)

    template <char... Cs1, char...Cs2>
CnstString<Cs1..., Cs2...> operator +(CnstString<Cs1...>, CnstString<Cs2...>) { return {}; }

    Finalmente, você RepeatStr<N, Str>teria um tipo para Str{} + .. + Str{}:

    template<int N, typename Str>
struct RepeatStr {
    // C++20
    using ret = decltype([]<std::size_t... Is>(std::index_sequence<Is...>){
        return ((static_cast<void>(Is), Str{}) + ...);
    }(std::make_index_sequence<N>()));
};

    Demonstração

    Como você está limitado ao C++ 14, substituindo a expressão fold do C++ 17 pela chamada de função "recursiva":

    template <typename T>
auto sum_impl(T t)
{
    return t;
}

template <typename T, typename... Ts>
auto sum_impl(T t, Ts... ts)
{
    return t + sum_impl(ts...);
}

    E substitua o template lambda(C++20) pela função de template regular:

    template <typename Str, std::size_t... Is>
auto repeat_impl(std::index_sequence<Is...>)
{
    return sum_impl((static_cast<void>(Is), Str{})...);
}

template<int N, typename Str>
struct RepeatStr {
    using ret = decltype(repeat_impl<Str>(std::make_index_sequence<N>()));
};

    Demonstração

    • 3

  2. Há algo de errado?

    Você precisa adicionar a palavra-chave templatena declaração using para informar ao compilador que push_backum modelo é usado.

    template<int N, typename Str>
struct RepeatStr {
    using ret = RepeatStr<N-1, Str>; 
};
template<typename Str>
struct RepeatStr<-1, Str> {
//--------------------vvvvvvvv------------------->works now
    using ret = Str:: template push_back<'\0'>;    
};

    Demonstração de trabalho

    • 1

relate perguntas