Início / coding / Perguntas / 79109124
Accepted
Chris Gnam
Asked: 2024-10-21 16:09:58 +0800 CST

Pacote de parâmetros para inicializar o membro std::array

  • 772

Tenho uma classe Colorque é um wrapper fino em torno de std::array. Gostaria de poder usá-la de duas maneiras:

  1. Color<5> color{1,2,3,4,5}deve produzircolor.values = [1,2,3,4,5]
  2. Color<5> color{3}deve produzircolor.values = [3,3,3,3,3]

O que eu tenho atualmente é:

template <size_t N>
class Color {
public:
    Color() = default;
    Color(std::array<float, N> values) : values{ values } {};

    template <IsNumeric... T>
    Color(T... v) : values{ static_cast<float>(v)... } { };

    ....

private:
    std::array<float, N> values;
}

Isso funciona corretamente para meu primeiro caso. No entanto, para o segundo caso, ele só produz: color.values = [3,0,0,0,0]. Estou perdido sobre como fazer o segundo caso funcionar. Eu tentei:

template <size_t N>
class Color {
public:
    Color() = default;
    Color(std::array<float, N> values) : values{ values } {};

    template <IsNumeric... T, typename std::enable_if<(sizeof...(T) == N), bool>::type = true>
    Color(T... v) : values{ static_cast<float>(v)... } { };

    template <IsNumeric T>
    Color(T v) : values{ std::array<float, N>{ static_cast<float>(v) } } { };

    ...
}

Mas isso não muda nada.

c++

3 respostas

  1. Best Answer

    Você pode fazer isso com a ajuda de std::index_sequencee uma função auxiliar. Como você já está usando conceitos, você deve usar uma requirescláusula para substituir std::enable_if.

    Seu código não mostra qual valuesé o tipo do membro, mas o título da pergunta, assim como o outro construtor, parece implicar que é a std::arraye é isso que eu uso aqui. De qualquer forma, deve funcionar, desde que o tipo de valuestenha um construtor variadic que faça a coisa correta.

    namespace detail{
    template <std::size_t... Is, typename T>
    constexpr std::array<float, sizeof...(Is)> makeValues(std::index_sequence<Is...>, T v){
        return {((void)Is, v)...};
    }
}

template <size_t N>
class Color {
public:
    constexpr Color() = default;
    //constexpr Color(std::array<float, N> values) : values{ values } {};

    template <IsNumeric... T> requires (sizeof...(T) == N)
    constexpr Color(T... v) : values{ static_cast<float>(v)... } { };

    template <IsNumeric T>
    constexpr Color(T v) : values{detail::makeValues(std::make_index_sequence<N>{}, static_cast<float>(v))} { };

    std::array<float, N> values;
};

    Isso pode ser verificado pela seguinte função principal de teste:

    int main(){
    static_assert(Color<2>{5,4}.values == std::array<float,2>{5,4});
    static_assert(Color<2>{5}.values == std::array<float,2>{5,5});
    // Color<3> doesntCompile{1,2};
}

    Demonstração: https://godbolt.org/z/KGeehW5x6

    • 5

  2. Você pode ter um único construtor usando uma função fillpadque preencherá até M itens no array (M sendo o número de itens na lista de inicialização).

    No caso de M<N, você pode completar o array com o último valor da lista.

    #include <array>

template<class T> concept IsNumeric = std::is_arithmetic_v<T>;

template <std::size_t N, IsNumeric...T>
constexpr auto fillpad (T... v) 
{
    static_assert (sizeof...(v) <= N);
    
    std::array<float,N> result {static_cast<float>(v)...};
    
    for (std::size_t i=sizeof...(v); i<N; i++) { result[i] = result[i-1]; }
    
    return result;
}

template <std::size_t N>
struct  Color 
{
    Color() = default;
    
    template <IsNumeric...T>
    constexpr Color(T... v) : values {fillpad<N>(v...)}  {}
    
    std::array<float,N> values;
};

static_assert (Color<5>{1,2,3,4,5}.values == std::array<float,5>{1,2,3,4,5});
static_assert (Color<5>{1,2,3,4}  .values == std::array<float,5>{1,2,3,4,4});
static_assert (Color<5>{1,2,3}    .values == std::array<float,5>{1,2,3,3,3});
static_assert (Color<5>{1,2}      .values == std::array<float,5>{1,2,2,2,2});
static_assert (Color<5>{1}        .values == std::array<float,5>{1,1,1,1,1});

int main() {}

    Demonstração

    Observe que se você quiser impor que 1 ou N argumentos sejam fornecidos, pode-se substituir o static_assertna fillpadfunção por:

    static_assert (sizeof...(v)==1 or sizeof...(v)==N);
    • 3

  3. Para tipos que precisam de "index_sequence" em sua interface, costumo colocá-lo como parâmetro de modelo:

    template <typename IntSeq> class ColorImpl;

// Helper for variadic expansion
template <std::size_t, typename T> using always_t = T;

template <size_t... Is>
class ColorImpl<std::index_sequence<Is...>>
{
    std::array<float, sizeof...(Is)> values{};
public:
    constexpr ColorImpl() = default;
    constexpr explicit ColorImpl(std::array<float, sizeof...(Is)> values) : values{ values }
    {}

    // requires to avoid conflicts with default constructor and "fill" constructor
    constexpr ColorImpl(always_t<Is, float>... fs) requires (sizeof...(Is) > 1) :
        values{ fs... }
    {}

    constexpr explicit ColorImpl(float f) : values{ (static_cast<void>(Is), f)... } {}

    // ...
};

template <std::size_t N>
using Color = ColorImpl<std::make_index_sequence<N>>;

    Demonstração

    • 3

relate perguntas