C++ C++；调用多种不同类型的函数

我有一个重载函数，我必须用许多不同的类型调用它。简单的方法是：

uint8_t a;
uint16_t b;
//....
double x;

doSomething(a);
doSomething(b);
//...
doSomething(x);

如本文所述，可以使用可变模板简洁地表达这些调用。代码看起来有点像这样：

auto doSomethingForAllTypes = [](auto&&... args) {
    (doSomething(args), ...);
};

uint8_t a;
uint16_t b;
//....
double x;

doSomethingForAllTypes(a, b, ... ,x);

auto doSomethingForAllTypes = [](auto&&... args) {
    (doSomething(args), ...);
};

someContainer allTypesNeeded(uint8_t, uint16_t, ... double);

doSomethingForAllTypes(allTypesNeeded);

但是我必须在代码中的许多地方这样做，所以我只想定义一次类型列表。我希望代码在概念上如下所示：

auto doSomethingForAllTypes = [](auto&&... args) {
    (doSomething(args), ...);
};

uint8_t a;
uint16_t b;
//....
double x;

doSomethingForAllTypes(a, b, ... ,x);

auto doSomethingForAllTypes = [](auto&&... args) {
    (doSomething(args), ...);
};

someContainer allTypesNeeded(uint8_t, uint16_t, ... double);

doSomethingForAllTypes(allTypesNeeded);

如何做到这一点？

有了一些，您可以按如下方式实现您想要的：

#include <tuple>
#include <utility>

namespace detail
{
    template<typename T, typename F, std::size_t... Is>
    void for_each(T&& t, F f, std::index_sequence<Is...>)
    {
        ( static_cast<void>(f(std::get<Is>(std::forward<T>(t)))),... );
    }
}

template<typename... Ts, typename F>
void for_each_in_tuple(std::tuple<Ts...> const& t, F f)
{
    detail::for_each(t, f, std::index_sequence_for<Ts...>{});
}

int main() {
    std::tuple<uint8_t, uint16_t, double> tup{};
    for_each_in_tuple(tup, [](auto&& arg) {
        doSomething(arg);
    });
}

#包括
#包括
名称空间详细信息
{
模板
每个（T&&T，F F，std:：index_序列）的void
{
（静态_cast（f（std：：get（std：：forward（t））），…）；
}
}
模板
元组中每个元组的空值（std:：tuple const&t，F）
{
细节：：对于每一个（t，f，std：：索引序列{}）；
}
int main（）{
std:：tuple tup{}；
对于\u元组中的每个\u（元组，[]（自动和参数）{
剂量测定法（arg）；
});
}

---

如果您想拥有预定义的类型序列，如果您不想创建带参数的元组，可以使用TypeList aproach：

#include <type_traits>
#include <utility>

void doSomething(int)
{
}

void doSomething(double)
{
}

template <typename... Args>
void doSomething(Args&&... args)
{
    (doSomething(std::forward<Args>(args)), ...);
}

template <typename ...Args>
struct TypeList{};

template <typename T>
struct DoSomethingHelper;

template <typename ...Args>
struct DoSomethingHelper<TypeList<Args...>>
{
    static void doSomething(Args&&... args)
    {
        ::doSomething(std::forward<Args>(args)...);
    }
};

template <typename T, typename ...Args>
void doSomethingForTypes(Args&&... args)
{
    DoSomethingHelper<T>::doSomething(std::forward<Args>(args)...);
}

int main()
{
    using MyTypeList = TypeList<int, double, int>;

    doSomethingForTypes<MyTypeList>(1, 1.0, 2);
}

#包括
#包括
无效剂量测量（int）
{
}
无效剂量（双）
{
}
模板
void doSomething（Args&…Args）
{
（剂量测定法（标准：正向（args）），…）；
}
模板
结构类型列表{}；
模板
结构DoSomethingHelper；
模板
结构DoSomethingHelper
{
静态无效剂量测定（参数&…参数）
{
：：剂量测量（标准：正向（参数）…）；
}
};
模板
void doSomethingForTypes（Args&…Args）
{
DoSomethingHelper：：doSomething（标准：：转发（args）…）；
}
int main（）
{
使用MyTypeList=类型列表；
doSomethingForTypes（1,1.0,2）；
}
带有
std:：tuple
和
std:：apply

std::tuple<uint8_t, uint16_t, double> tup{};
std::apply([](const auto&... arg) { (doSomething(arg), ...); }, tup);

std:：tuple tup{}；
std:：apply（[]（const auto&…arg）{（doSomething（arg），…）；}，tup）；
准确地说，您希望缩短哪些代码？您想多次调用doSomethingForAllType
？正在推导
doSomethingForAllType
中的类型。带参数的调用应该是什么样子？在我看来像是
std:：tuple
和
std:：apply
。