登录
当前位置： 首页 > 知识库问答 >
问题：

如何使通用计算对异构参数包的变量模板函数？

鲍建业
2023-03-14

前提：

在玩了一点可变模板之后，我意识到实现稍微超出琐碎的元编程任务的任何东西很快就会变得相当麻烦。特别是，我发现自己希望有一种方法可以在参数包上执行泛型操作，比如迭代、拆分、在std:：for_each-类似的方式中循环等等。

在观看了Andrei Alexandresu从C和超越2012关于静态如果进入C（借用自D编程语言的构造）的可取性的讲座后，我有一种感觉，某种静态的将会出现也很方便——我觉得更多的这些静态结构可以带来好处。

所以我开始想是否有一种方法可以为变量模板函数（伪代码）的参数包实现这样的东西：

template<typename... Ts>
void my_function(Ts&&... args)
{
    static for (int i = 0; i < sizeof...(args); i++) // PSEUDO-CODE!
    {
        foo(nth_value_of<i>(args));
    }
}

这将在编译时转换为如下内容：

template<typename... Ts>
void my_function(Ts&&... args)
{
    foo(nth_value_of<0>(args));
    foo(nth_value_of<1>(args));
    // ...
    foo(nth_value_of<sizeof...(args) - 1>(args));
}

原则上，static_for将允许更复杂的处理：

template<typename... Ts>
void foo(Ts&&... args)
{
    constexpr s = sizeof...(args);

    static for (int i = 0; i < s / 2; i++)
    {
        // Do something
        foo(nth_value_of<i>(args));
    }

    static for (int i = s / 2; i < s; i++)
    {
        // Do something different
        bar(nth_value_of<i>(args));
    }
}

或者对于像这样一个更具表现力的成语：

template<typename... Ts>
void foo(Ts&&... args)
{
    static for_each (auto&& x : args)
    {
        foo(x);
    }
}

相关工作：

我在网上搜索了一下，发现确实存在一些东西：

  • 此链接介绍如何将参数包转换为Boost。MPL向量，但这只是实现目标的一半（如果不是更少的话）

问题:

有没有一种相对简单的方法，可能是通过一些模板元编程，来实现我想要的东西，而不会受到现有方法的限制？

共有3个答案

卫骏
2023-03-14

使用枚举解决方案（ala Python）。

用法：

void fun(int i, size_t index, size_t size) {
    if (index != 0) {
        std::cout << ", ";
    }

    std::cout << i;

    if (index == size - 1) {
        std::cout << "\n";
    }
} // fun

enumerate(fun, 2, 3, 4);

// Expected output: "2, 3, 4\n"
// check it at: http://liveworkspace.org/code/1cydbw$4

代码：

// Fun: expects a callable of 3 parameters: Arg, size_t, size_t
// Arg: forwarded argument
// size_t: index of current argument
// size_t: number of arguments
template <typename Fun, typename... Args, size_t... Is>
void enumerate_impl(Fun&& fun, index_list<Is...>, Args&&... args) {
    std::initializer_list<int> _{
        (fun(std::forward<Args>(args), Is, sizeof...(Is)), 0)...
    };
    (void)_; // placate compiler, only the side-effects interest us
}

template <typename Fun, typename... Args>
void enumerate(Fun&& fun, Args&&... args) {
    enumerate_impl(fun,
                   index_range<0, sizeof...(args)>(),
                   std::forward<Args>(args)...);
}

范围生成器（从您的解决方案中窃取）：

// The structure that encapsulates index lists
template <size_t... Is>
struct index_list
{
};

// Collects internal details for generating index ranges [MIN, MAX)
namespace detail
{
    // Declare primary template for index range builder
    template <size_t MIN, size_t N, size_t... Is>
    struct range_builder;

    // Base step
    template <size_t MIN, size_t... Is>
    struct range_builder<MIN, MIN, Is...>
    {
        typedef index_list<Is...> type;
    };

    // Induction step
    template <size_t MIN, size_t N, size_t... Is>
    struct range_builder : public range_builder<MIN, N - 1, N - 1, Is...>
    {
    };
}

// Meta-function that returns a [MIN, MAX) index range
template<size_t MIN, size_t MAX>
using index_range = typename detail::range_builder<MIN, MAX>::type;
夏侯航
2023-03-14

根据讨论，让我发布以下代码：

#include <initializer_list>
#define EXPAND(EXPR) std::initializer_list<int>{((EXPR),0)...}

// Example of use:
#include <iostream>
#include <utility>

void print(int i){std::cout << "int: " << i << '\n';}
int print(double d){std::cout << "double: " << d << '\n';return 2;}

template<class...T> void f(T&&...args){
  EXPAND(print(std::forward<T>(args)));
}

int main(){
  f();
  f(1,2.,3);
}

我用g-std=c11-O1检查生成的代码，并且main只包含3个对print的调用，没有扩展助手的痕迹。

周浩博
2023-03-14

因为我对我的发现不满意，所以我试图自己找到一个解决方案，并最终编写了一个小型库，允许在参数包上制定通用操作。我的解决方案具有以下功能：

  • 允许迭代参数包的所有或某些元素，可能通过计算参数包上的索引来指定

我将首先展示如何使用该库，然后发布其实现。

使用案例

下面是一个示例，说明如何使用\u arg\u pack（）函数中的for\u each\u迭代包的所有参数，并将输入中的每个参数传递给客户端提供的某个函子（当然，如果参数包包含异构类型的值，则函子必须具有通用调用运算符）：

// Simple functor with a generic call operator that prints its input. This is used by the
// following functors and by some demonstrative test cases in the main() routine.
struct print
{
    template<typename T>
    void operator () (T&& t)
    {
        cout << t << endl;
    }
};

// This shows how a for_each_*** helper can be used inside a variadic template function
template<typename... Ts>
void print_all(Ts&&... args)
{
    for_each_in_arg_pack(print(), forward<Ts>(args)...);
}

上面的print函子也可以用于更复杂的计算。特别是，下面是如何迭代包中参数的子集（在本例中为子范围）：

// Shows how to select portions of an argument pack and 
// invoke a functor for each of the selected elements
template<typename... Ts>
void split_and_print(Ts&&... args)
{
    constexpr size_t packSize = sizeof...(args);
    constexpr size_t halfSize = packSize / 2;

    cout << "Printing first half:" << endl;
    for_each_in_arg_pack_subset(
        print(), // The functor to invoke for each element
        index_range<0, halfSize>(), // The indices to select
        forward<Ts>(args)... // The argument pack
        );

    cout << "Printing second half:" << endl;
    for_each_in_arg_pack_subset(
        print(), // The functor to invoke for each element
        index_range<halfSize, packSize>(), // The indices to select
        forward<Ts>(args)... // The argument pack
        );
}

有时，人们可能只想将参数包的一部分转发给其他一些可变仿函数，而不是迭代其元素，并将其中的每一个单独传递给非可变仿函数。这就是forward_subpack（）算法允许做的事情：

// Functor with variadic call operator that shows the usage of for_each_*** 
// to print all the arguments of a heterogeneous pack
struct my_func
{
    template<typename... Ts>
    void operator ()(Ts&&... args)
    {
        print_all(forward<Ts>(args)...);
    }
};

// Shows how to forward only a portion of an argument pack 
// to another variadic functor
template<typename... Ts>
void split_and_print(Ts&&... args)
{
    constexpr size_t packSize = sizeof...(args);
    constexpr size_t halfSize = packSize / 2;

    cout << "Printing first half:" << endl;
    forward_subpack(my_func(), index_range<0, halfSize>(), forward<Ts>(args)...);

    cout << "Printing second half:" << endl;
    forward_subpack(my_func(), index_range<halfSize, packSize>(), forward<Ts>(args)...);
}

对于更具体的任务，当然可以通过索引来检索包中的特定参数。这就是nth_value_of（）函数允许做的事情，以及它的助手first_value_of（）和last_value_of（）：

// Shows that arguments in a pack can be indexed
template<unsigned I, typename... Ts>
void print_first_last_and_indexed(Ts&&... args)
{
    cout << "First argument: " << first_value_of(forward<Ts>(args)...) << endl;
    cout << "Last argument: " << last_value_of(forward<Ts>(args)...) << endl;
    cout << "Argument #" << I << ": " << nth_value_of<I>(forward<Ts>(args)...) << endl;
}

另一方面，如果参数包是同质的（即所有参数都具有相同的类型），下面的公式可能更可取。is_homogeneous_pack

// Shows the use of range-based for loops to iterate over a
// homogeneous argument pack
template<typename... Ts>
void print_all(Ts&&... args)
{
    static_assert(
        is_homogeneous_pack<Ts...>::value, 
        "Template parameter pack not homogeneous!"
        );

    for (auto&& x : { args... })
    {
        // Do something with x...
    }

    cout << endl;
}

最后，由于lambda只是函子的语法糖，它们也可以与上面的算法结合使用；然而，在C支持泛型lambda之前，这只适用于同质参数包。下面的示例还显示了同质类型的用法

 // ...
 static_assert(
     is_homogeneous_pack<Ts...>::value, 
     "Template parameter pack not homogeneous!"
     );
 using type = homogeneous_type<Ts...>::type;
 for_each_in_arg_pack([] (type const& x) { cout << x << endl; }, forward<Ts>(args)...);

这基本上是库允许做的，但我相信它甚至可以扩展到执行更复杂的任务。

实施

现在是实现，这本身有点棘手，因此我将依靠注释来解释代码，并避免将此帖子写得太长（可能已经是这样了）：

#include <type_traits>
#include <utility>

//===============================================================================
// META-FUNCTIONS FOR EXTRACTING THE n-th TYPE OF A PARAMETER PACK

// Declare primary template
template<int I, typename... Ts>
struct nth_type_of
{
};

// Base step
template<typename T, typename... Ts>
struct nth_type_of<0, T, Ts...>
{
    using type = T;
};

// Induction step
template<int I, typename T, typename... Ts>
struct nth_type_of<I, T, Ts...>
{
    using type = typename nth_type_of<I - 1, Ts...>::type;
};

// Helper meta-function for retrieving the first type in a parameter pack
template<typename... Ts>
struct first_type_of
{
    using type = typename nth_type_of<0, Ts...>::type;
};

// Helper meta-function for retrieving the last type in a parameter pack
template<typename... Ts>
struct last_type_of
{
    using type = typename nth_type_of<sizeof...(Ts) - 1, Ts...>::type;
};

//===============================================================================
// FUNCTIONS FOR EXTRACTING THE n-th VALUE OF AN ARGUMENT PACK

// Base step
template<int I, typename T, typename... Ts>
auto nth_value_of(T&& t, Ts&&... args) ->
    typename std::enable_if<(I == 0), decltype(std::forward<T>(t))>::type
{
    return std::forward<T>(t);
}

// Induction step
template<int I, typename T, typename... Ts>
auto nth_value_of(T&& t, Ts&&... args) ->
    typename std::enable_if<(I > 0), decltype(
        std::forward<typename nth_type_of<I, T, Ts...>::type>(
            std::declval<typename nth_type_of<I, T, Ts...>::type>()
            )
        )>::type
{
    using return_type = typename nth_type_of<I, T, Ts...>::type;
    return std::forward<return_type>(nth_value_of<I - 1>((std::forward<Ts>(args))...));
}

// Helper function for retrieving the first value of an argument pack
template<typename... Ts>
auto first_value_of(Ts&&... args) ->
    decltype(
        std::forward<typename first_type_of<Ts...>::type>(
            std::declval<typename first_type_of<Ts...>::type>()
            )
        )
{
    using return_type = typename first_type_of<Ts...>::type;
    return std::forward<return_type>(nth_value_of<0>((std::forward<Ts>(args))...));
}

// Helper function for retrieving the last value of an argument pack
template<typename... Ts>
auto last_value_of(Ts&&... args) ->
    decltype(
        std::forward<typename last_type_of<Ts...>::type>(
            std::declval<typename last_type_of<Ts...>::type>()
            )
        )
{
    using return_type = typename last_type_of<Ts...>::type;
    return std::forward<return_type>(nth_value_of<sizeof...(Ts) - 1>((std::forward<Ts>(args))...));
}

//===============================================================================
// METAFUNCTION FOR COMPUTING THE UNDERLYING TYPE OF HOMOGENEOUS PARAMETER PACKS

// Used as the underlying type of non-homogeneous parameter packs
struct null_type
{
};

// Declare primary template
template<typename... Ts>
struct homogeneous_type;

// Base step
template<typename T>
struct homogeneous_type<T>
{
    using type = T;
    static const bool isHomogeneous = true;
};

// Induction step
template<typename T, typename... Ts>
struct homogeneous_type<T, Ts...>
{
    // The underlying type of the tail of the parameter pack
    using type_of_remaining_parameters = typename homogeneous_type<Ts...>::type;

    // True if each parameter in the pack has the same type
    static const bool isHomogeneous = std::is_same<T, type_of_remaining_parameters>::value;

    // If isHomogeneous is "false", the underlying type is the fictitious null_type
    using type = typename std::conditional<isHomogeneous, T, null_type>::type;
};

// Meta-function to determine if a parameter pack is homogeneous
template<typename... Ts>
struct is_homogeneous_pack
{
    static const bool value = homogeneous_type<Ts...>::isHomogeneous;
};

//===============================================================================
// META-FUNCTIONS FOR CREATING INDEX LISTS

// The structure that encapsulates index lists
template <unsigned... Is>
struct index_list
{
};

// Collects internal details for generating index ranges [MIN, MAX)
namespace detail
{
    // Declare primary template for index range builder
    template <unsigned MIN, unsigned N, unsigned... Is>
    struct range_builder;

    // Base step
    template <unsigned MIN, unsigned... Is>
    struct range_builder<MIN, MIN, Is...>
    {
        typedef index_list<Is...> type;
    };

    // Induction step
    template <unsigned MIN, unsigned N, unsigned... Is>
    struct range_builder : public range_builder<MIN, N - 1, N - 1, Is...>
    {
    };
}

// Meta-function that returns a [MIN, MAX) index range
template<unsigned MIN, unsigned MAX>
using index_range = typename detail::range_builder<MIN, MAX>::type;

//===============================================================================
// CLASSES AND FUNCTIONS FOR REALIZING LOOPS ON ARGUMENT PACKS

// Implementation inspired by @jogojapan's answer to this question:
// http://stackoverflow.com/questions/14089637/return-several-arguments-for-another-function-by-a-single-function

// Collects internal details for implementing functor invocation
namespace detail
{
    // Functor invocation is realized through variadic inheritance.
    // The constructor of each base class invokes an input functor.
    // An functor invoker for an argument pack has one base class
    // for each argument in the pack

    // Realizes the invocation of the functor for one parameter
    template<unsigned I, typename T>
    struct invoker_base
    {
        template<typename F, typename U>
        invoker_base(F&& f, U&& u) { f(u); }
    };

    // Necessary because a class cannot inherit the same class twice
    template<unsigned I, typename T>
    struct indexed_type
    {
        static const unsigned int index = I;
        using type = T;
    };

    // The functor invoker: inherits from a list of base classes.
    // The constructor of each of these classes invokes the input
    // functor with one of the arguments in the pack.
    template<typename... Ts>
    struct invoker : public invoker_base<Ts::index, typename Ts::type>...
    {
        template<typename F, typename... Us>
        invoker(F&& f, Us&&... args)
            :
            invoker_base<Ts::index, typename Ts::type>(std::forward<F>(f), std::forward<Us>(args))...
        {
        }
    };
}

// The functor provided in the first argument is invoked for each
// argument in the pack whose index is contained in the index list
// specified in the second argument
template<typename F, unsigned... Is, typename... Ts>
void for_each_in_arg_pack_subset(F&& f, index_list<Is...> const& i, Ts&&... args)
{
    // Constructors of invoker's sub-objects will invoke the functor.
    // Note that argument types must be paired with numbers because the
    // implementation is based on inheritance, and one class cannot
    // inherit the same base class twice.
    detail::invoker<detail::indexed_type<Is, typename nth_type_of<Is, Ts...>::type>...> invoker(
        f,
        (nth_value_of<Is>(std::forward<Ts>(args)...))...
        );
}

// The functor provided in the first argument is invoked for each
// argument in the pack
template<typename F, typename... Ts>
void for_each_in_arg_pack(F&& f, Ts&&... args)
{
    for_each_in_arg_pack_subset(f, index_range<0, sizeof...(Ts)>(), std::forward<Ts>(args)...);
}

// The functor provided in the first argument is given in input the
// arguments in whose index is contained in the index list specified
// as the second argument.
template<typename F, unsigned... Is, typename... Ts>
void forward_subpack(F&& f, index_list<Is...> const& i, Ts&&... args)
{
    f((nth_value_of<Is>(std::forward<Ts>(args)...))...);
}

// The functor provided in the first argument is given in input all the
// arguments in the pack.
template<typename F, typename... Ts>
void forward_pack(F&& f, Ts&&... args)
{
    f(std::forward<Ts>(args)...);
}

结论

当然，即使我对这个问题提供了自己的答案（实际上是因为这个事实），我也很想知道除了问题的“相关工程”部分提到的那些之外，是否存在我错过的替代或更好的解决方案。

 类似资料：
  • 如何定义变量类模板的成员模板函数

    我试图用成员模板函数实现一个可变类模板，其模板参数独立于类模板参数，但在定义成员模板时遇到了问题。 我将问题简化为尝试编译此文件（抱歉，无法进一步简化）： 在尝试编译（C 11）时，我遇到以下错误： 我很确定它归结为第一个和第五个错误，但不知道我做错了什么。为什么

  • C++11可变参数模板（函数模板、类模板）

    在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。可变参数模板的加入使得C++11的功能变得更加强大，而由此也带来了许多神奇的用法。 可变参数模板 可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号...： template<ty

  • 具有可变参数模板构造函数的演绎指南和可变参数类模板 - 参数包长度不匹配

    请考虑以下定义和演绎指南： 如果我尝试使用显式模板参数实例化 ，代码将正确编译： 如果我试图通过演绎指南实例化< code>foo... > G7产生编译器错误： clang 5 爆炸： wandbox上的实例 虽然clang肯定被窃听了（报告为问题#32673），但g拒绝我的代码是正确的吗？我的代码格式错误吗？

  • 在类模板的变量函数模板上定义成员变量

    我试图在变量函数模板上使用'decltype'来获取其返回值类型，然后使用它来定义成员变量。但我一直在犯这样的错误： 基本上，decltype失败并将声明为int，而不是推断的返回类型。 它的工作原理是当我提供的所有参数的值，但这不是我要找的行为。因为我不知道该函数有多少参数，所以它必须保持为可变模板函数。 我计划如何使用类模板的示例： 如果我没有任何成员变量，并使用作为： 它编译，因此我相信能够

  • 如何：捕获输入函数异常的变量包装函数

    我正在尝试创建一个可以传递其他函数的函数，它将捕获任何错误，但只返回函数的返回值。以下是我尝试过的： 我希望意图相对明确；我希望能够接收任何类型的函数，并返回其返回值（只要在出错的情况下隐式可转换为该值）。然而，当我试图编译上述代码时，我得到了这些类型的错误； 掠夺。cpp:10:78:错误：应在“…”之前使用主表达式令牌静态自动处理呼叫（const F 很明显，我没有正确地使用可变模板。。。有什

  • 模板包含的模板中的变量

    问题内容： 我试图将值放入“标题”模板中，例如标题和导航链接，但无法访问我从包含的模板发送到主模板的变量。 渲染模板： index.html模板： header.html模板： 显然，它不会那样工作。 也许有一种方法可以解析/获取模板并将变量放入其中，而无需将整个头文件放入代码中？然后，我可以将该模板作为变量发送到我的主模板。但这似乎并不是最好的方法。 问题答案： 您可以在调用模板时将上下文传递给

相关问答

使用模板专门化拆分可变参数包我如何做可变参数的可变模板如何使用布尔模板参数启用成员函数？将具有可变模板参数的成员函数传递给可变构造函数将可变参数模板与 C 样式可变参数函数混合时的模板参数推导

相关文章

计算flask模板中的行数如何使用结构或变量值的字段作为模板名称？Django-如何使变量可用于所有模板？如何使用PowerMockito模拟构造函数Java如何用负数计算模数？

相关阅读

C语言函数中的变量（包括：作用域、存储类型）Go语言函数变量C++类和对象、构造函数和析构函数C++函数模板入门教程UX面试｜如何实践通用/包容性设计的

相关工具

Axiom计算机代数系统PHPnow模板引擎qtcreator项目模板功能齐全的计算器计算机进化

相关文档

OpenCL 2.0 异构计算小米函数计算开发文档SQL 合计函数设计模式包教不包会数据结构和算法
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.