c++ - 给定一个具有任意数量的具有不同类型的向量的元组，我如何提取具有最小大小的向量？

给定一个包含不同类型向量的元组，我如何提取最小大小的向量？

~~你不能~~你不能直接。

因为它们是不同的类型，所以决定是基于值（而不是类型），所以你无法决定提取的编译时间（std::tuplecan't be constexpr）的类型，而C++是一种强类型语言。

您可以做的最简单的事情是提取具有最小大小的向量的索引。因为在这种情况下，提取的值是一个整数（std::size_t例如），您可以遍历元组中的向量以选择具有较少元素的向量。

不同的是，如果您必须提取std::array最小尺寸的

auto t = std::make_tuple(std::array<int, 2u>({1,2}),
                         std::array<double, 3u>({1.0, 2.0, 3.0}));

因为大小（2u第一个，3u第二个）是已知的编译时间，所以你可以选择第二个数组编译时间。

如果您可以使用 C++17，则可以使用std::variant, 一个可以包含所有类型的元组的类型。

正如 Caleth 所指出的（谢谢），如果您只能将 C++11/C++14 与 boost 库一起使用，则可以使用boost::variant. 但我不知道，所以我不能给你看一个具体的例子（但你可以看到 Caleth 的回答）

以下是具有两种类型的元组的示例

template <typename T1, typename T2>
std::variant<T1, T2> getLess (std::tuple<T1, T2> const & tp)
 {
   std::variant<T1, T2>  v;

   if ( std::get<0>(tp).size() < std::get<1>(tp).size() )
       v = std::get<0>(tp);
   else
       v = std::get<1>(tp);

   return v;
 }

int main ()
 {
   std::vector<int>     vi {1, 2, 3};
   std::vector<double>  vd {1.0, 2.0};

   auto gl = getLess(std::make_tuple(vi, vd));
 }

这适用于两种类型的元组。但是使用 N 类型的元组（N高）变得复杂，因为你不能写一些东西

auto min_length = std::get<0>(tp).size();
auto min_index  = 0u;

for ( auto ui = 1u ; ui < N ; ++ui )
   if ( std::get<ui>(tp).size() < min_length )
    {
       min_length = std::get<ui>(tp).size();
       min_index  = ui;
    }

因为您不能将std::get<>()运行时值作为ui.

分配变体的同样问题。你不能简单地写

v = std::get<min_index>(tp);

因为min_index是运行时值。

你必须通过一个switch()

switch ( min_length )
 {
   case 0: v = std::get<0>(tp); break;
   case 1: v = std::get<1>(tp); break;
   case 2: v = std::get<2>(tp); break;
   case 3: v = std::get<3>(tp); break;
   case 4: v = std::get<4>(tp); break;

   // ...

   case N-1: v = std::get<N-1>(tp); break;
 };

或类似的东西。

getLess()如您所见，如果您希望该函数是可变参数，它会变得越来越复杂。

对于可变参数情况，我能想象的最好的（但是是 C++17 解决方案；请参阅 Caleth 对 C++11 解决方案的回答）是使用辅助函数和模板折叠，如下所示。

#include <tuple>
#include <vector>
#include <variant>
#include <iostream>

template <typename ... Ts, std::size_t ... Is>
auto getLessHelper (std::tuple<Ts...> const & tp,
                    std::index_sequence<0, Is...> const &)
 {
   std::variant<Ts...> var_ret  { std::get<0>(tp) };
   std::size_t         min_size { std::get<0>(tp).size() };

   ((std::get<Is>(tp).size() < min_size ? (var_ret = std::get<Is>(tp),
                                           min_size = std::get<Is>(tp).size())
                                        : 0u), ...);

   return var_ret;
 }

template <typename ... Ts>
auto getLess (std::tuple<Ts...> const & tp)
 { return getLessHelper(tp, std::index_sequence_for<Ts...>{}); }

int main ()
 {
   std::vector<int>     vi {1, 2, 3};
   std::vector<double>  vd {1.0, 2.0};
   std::vector<float>   vf {1.0f};

   auto gl = getLess(std::make_tuple(vi, vd, vf));

   std::cout << std::visit([](auto const & v){ return v.size(); }, gl)
       << std::endl; // print 1, the size() of vf
 }

c++ - 给定一个具有任意数量的具有不同类型的向量的元组，我如何提取具有最小大小的向量？

问题描述

解决方案

推荐阅读