可变参函数

C库宏实现

#include <stdarg.h>

void va_start(va_list ap,last_arg);
参数：
  	ap va_list 类型，va_start 函数用来初始化ap 变量，它用来存储通过 va_arg 获取额外参数时所必需的信息
  	last_arg 是最后一个传递给函数已知的固定参数，即省略号之前的参数
作用：
  初始化ap变量
调用时机：
  在va_arg 和 va_end 之间被调用
  
//-------------------------------------
  type va_arg(va_list ap,type)
  
 参数：
  	ap va_start 初始化的变量
  	type 参数列表中元素的类型
 作用：
  	检索函数参数列表中类型为 type 的下一个参数。它无法判断检索到的参数是否是传给函数的最后一个参数。

//-------------------------------------
va_end 清理为ap保留的内存，如果在从函数返回之前没有调用 va_end，则结果为未定义。

//求和
int sum(int count,...)
{
    va_list ap;
    int sum = 0;

    va_start(ap,count);

    for(int i = 0;i<count;++i)
    {
        sum += va_arg(ap,int);
    }

    va_end(ap);

    return sum;
}

//sum(3,12,2,1); //3 代表参数的个数 ，后面的每一个都是参数

//该方法是极不安全的，宏本身无法提供任何安全性保证

c++11 的initializer_list

#include <initializer_list>
using namespace std; // std 命名空间的

int sum(initializer_list<int> ll)
{
    int sum = 0;
    
    for(auto p = ll.begin();p!=ll.end();++p)
    {
        sum += *p;
    }

    return sum;
}

//调用：
sum({12,2,34,10}); //用{}括住参数

//编译加上 -std=c++11

可变参数模板

• 可变参数模板和普通模板的写法类似，用...表示0到多个不同类型的参数

template<typename T>  //原始的不可变参数的形式
template<typename... T> //可变参数，0到多个
template<typename T1,typename... T2> //1到多个参数

• 打印多个不同类型的数据.

#include <iostream>

void print(){} //0个参数的调用函数

template<typename T,typename... T2>
void print(const T& firstArg,const T2&... args)
{
  std::cout<<firstArg<<"\t除去第一个参数，后面可变参数的个数："<<sizeof...(args)<<std::endl;
  std::cout << __PRETTY_FUNCTION__ << "\n";
  print(args...);
}

int main(void)
{
  print("hello",1,22.34);
  return. 0;
}

//编译 g++ xxx.cpp -std=c++11

//out:
/*
hello   除去第一个参数，后面可变参数的个数： 2
void print(const T &, const T2 &...) [T = char [6], T2 = <int, double>]
1       除去第一个参数，后面可变参数的个数： 1
void print(const T &, const T2 &...) [T = int, T2 = <double>]
22.34   除去第一个参数，后面可变参数的个数： 0
void print(const T &, const T2 &...) [T = double, T2 = <>]
*/



//说明：
//sizeof...(args) 获取args的参数个数

• 比较多个数的大小

#include <iostream>
using namespace std;

template<typename T>
T myMax(T value)
{
    return value;
}

template<typename T,typename...Type>
T myMax(T firstArg,Type...args)
{
    cout << __PRETTY_FUNCTION__ << "\n";
    return max(firstArg,myMax(args...));
    
}

int main(void)
{

    int max_num = myMax<int>(1,23,99,67,10);
    cout<<max_num<<endl;
    return 0;
}

//out
/*
T myMax(T, Type...) [T = int, Type = <int, int, int, int>]
T myMax(T, Type...) [T = int, Type = <int, int, int>]
T myMax(T, Type...) [T = int, Type = <int, int>]
T myMax(T, Type...) [T = int, Type = <int>]
99

*/