当前位置 : 主页 > 编程语言 > 其它开发 >

C/C++中的可变参数和可变参数模板

来源:互联网 收集:自由互联 发布时间:2022-05-30
就从个人理解上说,可变参数就是函数传参的时候,不确定传入参数的数量和类型,从而动态地在函数内部处理,优点是,函数调用时比较灵活 目录 1、说明 2、C语言中的可变参数 3、
就从个人理解上说,可变参数就是函数传参的时候,不确定传入参数的数量和类型,从而动态地在函数内部处理,优点是,函数调用时比较灵活

目录
  • 1、说明
  • 2、C语言中的可变参数
  • 3、C++中的可变参数模板
    • 2.1、使用递归的方式遍历
    • 2.2、使用非递归的方式遍历

1、说明

不谈官方定义,就从个人理解上说,可变参数 就是函数传参的时候,不确定传入参数的数量和类型,从而动态地在函数内部处理,优点是,函数调用时比较灵活

2、C语言中的可变参数

C语言中一般使用宏定义实现可变参数,先看一个示例:

#include <stdarg.h>
void func(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);

    auto a = va_arg(ap, int);
    auto b = va_arg(ap, double);
    auto c = va_arg(ap, char*);
    
    cout << a << ", " << b << ", " << c << endl;
    va_end(ap);
}
int main()
{
    func("%d %f %s\n", 1, 2.0f, "hello world");
    return 0;
}

这是一个很常见的C语言的可变参数的使用,va_start 用于初始化 va_list 变量,va_arg 用于提取可变参数,va_end 用于释放 va_list

这个示例可以用在一般函数上,无法使用在宏定义中,如果一定要在宏定义中使用,需要配合 __VA_ARGS__,示例如下:

//#define CALC(fmt, ...) func(fmt, ...) //错误的使用
#define CALC(fmt, ...) func(fmt, __VA_ARGS__)
int main()
{
    CALC("%d %f %s\n", 1, 2.0f, "hello world");
    return 0;
}
3、C++中的可变参数模板

C++11 中引入了新的功能,可变参数模版,语法如下:

template <typename T, typename ... Args>
void func(T t,Args ... args);

这里面,Args 称之为模板参数包(template parameter pack),表示模板参数位置上的变长参数,

args 称之为函数参数包(function parameter pack),表示函数参数位置上的变长参数

可以使用 sizeof...() 获取可变参数数目

先看一个示例:

template<typename... Args>
void print(Args... args)
{
    int num = sizeof...(args);
}
int main()
{
    print(1, 2, "123", 4);
    return 0;
}

执行结果是:

4
2.1、使用递归的方式遍历

可变参数一般使用递归的方式进行遍历,利用模板的推导机制,每次从可变参数中取出第一个元素,直到包为空

缺点:递归毕竟是使用栈内存,过多的递归层级容易导致爆栈的发生

示例代码如下:

void printf()
{
    cout << "end" << endl;
}
template<typename T, typename... Args>
void print(const T &value, Args... args)
{
    cout << value << endl;
    print(args...);
}
int main()
{
    print(1, 2, "333", 4);
    return 0;
}

结果输出如下:

1
2
333
4
end

这里不是很好理解,我们可以自己理解 print() 方法的每一次调用

  1. main函数中第一次调用,value为1, args有2、"333和4三个值,输出1;
  2. 第一次递归,即print中调用print,value为2,args有“333”和4两个值,输出2;
  3. 第二次递归,即print中调用print,value为“333”,args为4,输出“333”;
  4. 第三次递归,即print中调用print,value为4,args无值,输出4;
  5. 此时,args因为无值,print(args...) 语句调用的就不再是模板函数,而是第一行的 print(),输出end;

所以,很好理解,为什么要先定义一个同名的函数,就是为了等可变参数经过几次推导之后,没有值的情况出现;

当然,递归遍历也可以这么写:

template<typename T>
void print(T value)
{
    cout << "end:" << value << endl;
}
template<typename T, typename... Args>
void print(const T &value, Args... args)
{
    cout << value << endl;
    print(args...);
}
int main()
{
    print(1, 2, "333", 4);
    return 0;
}

结果输出:

1
2
333
end:4

这和第一个例子只有些许区别,函数调用如下:

  1. main函数中第一次调用,value为1, args有2、"333和4三个值,输出1;
  2. 第一次递归,即print中调用print,value为2,args有“333”和4两个值,输出2;
  3. 第二次递归,即print中调用print,value为“333”,args为4,输出“333”;
  4. 此时,args为4,print(args...) 语句调用的就不再是模板函数,而是第一行的 print(4),输出end:4;
2.2、使用非递归的方式遍历

利用 std::initializer_list ,即初始化列表展开可变参数

示例1,使用展开函数处理参数:

template<typename T>
void run(const T &t)
{
    cout << t << endl;
}
template<typename... Args>
void print(Args... args)
{
    std::initializer_list<int>{(run(args), 0)...};
}
int main()
{
    print(1, 2, "333as", 4);
    return 0;
}

示例2,使用lambda:

template<typename... Args>
void print(Args... args)
{
    std::initializer_list<int>{([&]
    { cout << args << endl; }(), 0)...};
}
int main()
{
    print(1, 2, "333as", 4);
    return 0;
}
上一篇:多线程JUC并发篇常见面试详解
下一篇:没有了
网友评论