使用 T 类型的 std::array 构造可从 T 构造的类型的 std::array

Question

请考虑以下类型：

struct Part
{
    float data;
};

struct Wrap
{
    Wrap( const Part& p )
        :data( p.data )
    {}
    float data;
};

现在我想使用std::array<Part, N> 来初始化std::array<Wrap, N>。

int main()
{
    std::array<Part, 3> parts{ Part{ 1.0f }, Part{ 2.0f }, Part{ 3.0f } };
    std::array<Wrap, 3> wrappers( parts );
    return 0;
}

（这会引发错误"conversion from 'std::array<Part, 3>' to non-scalar type 'std::array<Wrap, 3>' requested"）

如何使用T 类型的std::array 来初始化可从T 构造的类型的std::array？

Answer 1

您可以使用辅助函数来自动转换：

// Convert each element based on a sequence of indices:
template<typename ToType, typename FromType, std::size_t... Indices>
std::array<ToType, sizeof...(Indices)>
convert_impl(const std::array<FromType, sizeof...(Indices)>& input, std::index_sequence<Indices...>)
{
    return {ToType(std::get<Indices>(input))...};
}

// Wraps convert_impl to hide the use of index_sequence from users:
template<typename ToType, typename FromType, std::size_t N>
std::array<ToType, N> convert(const std::array<FromType, N>& input)
{
    return convert_impl<ToType>(input, std::make_index_sequence<N>{});
}

int main()
{
    std::array<Part, 3> parts {Part{1.0f}, Part{2.0f}, Part{3.0f}};
    std::array<Wrap, 3> wraps = convert<Wrap>(parts);

    return 0;
}

Answer 2

可能的简单选项有：

哦。请改用vector（数组仍然是邪恶的0_o）。

    std::vector<Part> ps{Part{1.0}, Part{2.0}, Part{3.0}};
    std::vector<Wrap> ws(ps.cbegin(), ps.cend());

我。明确说明。

    std::array<Part, 3> parts{ Part{ 1.0f }, Part{ 2.0f }, Part{ 3.0f } };
    std::array<Wrap, 3> wrappers = {parts[0], parts[1], parts[2]};

二。拆分构造和初始化。

struct Unwrap {
    Unwrap() {}
    Unwrap(Part const &p): data(p.data) {}
    float data;
};

int main() {
    std::array<Part, 3> parts{ Part{ 1.0f }, Part{ 2.0f }, Part{ 3.0f } };
    std::array<Unwrap, 3> unwrappers;
    std::copy(parts.cbegin(), parts.cend(), unwrappers.begin());
}

顺便说一句，Part 初始化中带括号的代码是否可以编译？我只能通过将它们更改为大括号来实现。