C++11-14 第1讲 Variadic Template（可变参数函数模板）

...从C就存在了

版权说明：本博文属于个人笔记，本人保留对本文的所有权益，未经许可不得以任何形式转载。

代码略去，可参考：https://blog.csdn.net/Cherish_2014/article/details/49256801

1.递归分解可变参数函数的参数包

#include<iostream>
#include<bitset>
using namespace std;
void print() {//接受空参数


}
//...就是pack（包）
template<typename T,typename... Types>//模板参数包
void print(const T&fristArg, const Types &...args) {//types函数参数类型包，args函数参数包
	cout << fristArg << "\t还有参数："<<sizeof...(args)<<""<<endl;//用sizeof...(参数包)求得还有参数数量
	print(args...);
}

template<typename... Types>
void print(const Types&...args) {//可并存，谁更泛化调用谁
	//print()
}


int main() {
	print(7.5, "hello", bitset<16>(377), 42);
	system("pause");
	return 0;
}

2.例子二，只是为了说明泛化的和特化的同名可变参函数调用问题

#include<iostream>
#include<functional>
#include<string>
using namespace std;

//④
template<typename T>
inline void hash_combine(size_t &seed, const T& val) {
	seed ^= std::hash<T>(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

//③
//备用通用函数
template<typename T>
inline void hash_val(size_t&seed, const T&val) {//调用不到这个，因为第一个参数为size_t
	hash_combine(seed, val);//调用①
}

//备用通用函数
//①
template<typename ...Types>
inline size_t hash_val(const Types&...args) {
	size_t seed = 0;
	hash_val(seed, args...);//调用②，调用特化的函数
	return seed;
}

//②
template<typename T,typename...Types>
inline void hash_val(size_t&seed, const T&val, const Types&...args) {
	hash_combine(seed, val);
	hash_val(seed, args...);//调用②，recursive。最后args为null，调用③
}



class Customer {
public:
	string fname, lname, no;
};
class CustomerHash {
public:
	std::size_t operator()(const Customer& c)const {
		return hash_val(c.fname, c.fname, c.no);
	}
};

int main() {
	//这里自己去做引用
	system("pause");
	return 0;
}

 

3.

 

，此处出处：博览网课

template<typename...Values>
class tuple {

};
template<>class tuple<>{};

template<typename Head,typename...Tail>
class tuple<Head, Tail...>
	:private tuple<Tail...> {//继承了一包
	typedef tuple<Tail...> inherited;
public:
	tuple(){ }
	tuple(Head v, Tail ...vtail) :m_head(v), inherited(vtail...) {}
	typename Head::type head() { return m_head; }
	inherit&tail{ return *this; }
protected:
	Head m_head;

};