使用 std::type T 的数组来构造可从 T 构造的 std::数组

Use std::array of type T to construct std::array of type constructable from T

本文关键字：数组 std type 使用      更新时间：2023-10-16

请考虑以下类型：

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？

您可以使用帮助程序函数来自动转换：

// 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;
}

可能的简单选项包括：

O. 改用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带有括号的代码甚至可以编译吗？我只能通过将它们更改为大括号来做到这一点。

相关文章：