博客

一：定义，泛化，全特化，偏特化，使用方法

#include <iostream>
#include <boost/type_index.hpp>
using namespace std;

//变量模板的泛化版本
template <typename T> //(1)
T g_tmp{};//变量的零初始化方式

//变量模板的全特化,,这里的char可以和int不一样
template<>//(2)
char g_tmp<float>{'a'};

//变量模板的偏特化,从参数范围上的偏特化，必须要求是T*，依赖于T
template<typename T>//(3)
T g_tmp <T*>{10};


//变量模板的偏特化,从参数范围上的偏特化，必须要求是T*，依赖于T
template<typename T>//(4)
T g_tmp <const T*>{100};

int main()
{
	/*
	变量模板：Variable Templates，c++14引入，一般写在.h文件当中
	从感觉上，变量模板与函数模板有些类似，看起来象一个没有参数，但是有返回值的函数模板*/

	//变量模板的,泛化，偏特化，以及全特化和使用
	g_tmp<int> = 20;
	std::cout << g_tmp<int> << std::endl;

	g_tmp<float>;
	std::cout << g_tmp<float> << std::endl;

	g_tmp <int*>;
	std::cout << g_tmp<int*> << std::endl;

	g_tmp <const int*>;
	std::cout << g_tmp<const int*> << std::endl;

	return 0;
}

二：变量模板默认模板参数

#include <iostream>
#include <boost/type_index.hpp>
using namespace std;

//变量模板,默认模板参数
template <typename T = int> 
T g_tmp{};//变量的零初始化方式

int main()
{
	g_tmp<int> = 5;
	g_tmp<> = 15;
	printf("%p,%d\n", &g_tmp<int>, g_tmp<int>);
	printf("%p,%d\n", &g_tmp<>, g_tmp<>);
	return 0;
}

三：非类型模板参数

#include <iostream>
#include <boost/type_index.hpp>
using namespace std;
//变量模板，非类型模板参数
template <typename T, int value> 
T g_tmp[value]{};//变量的零初始化方式
int main()
{
	for (int i = 0; i < 15; i++)
	{
		g_tmp<int, 15>[i] = i;  //g_tmp<int, 15>出现就代表定义了g_tmp[value]这么一个数组
	}
	for (int i = 0; i < 15; i++)
	{
		std::cout << g_tmp<int, 15>[i] << '\t';
	}
	return 0;
}

四：变量模板的另一种形式

#include <iostream>
#include <boost/type_index.hpp>
using namespace std;

//变量模板，另一种表现形式
template <typename T>
struct B
{
	const static T value = { 160 }; //const也可以写成constexpr,{}也可以不加,注意是静态成员变量
};

template <typename T>
int g_tmp = B<T>::value; //注意g_tmp是个变量模板
int main()
{
	cout << g_tmp<int> << endl; //160,g_tmp<int>相当于B<int>::value

	printf("%p\n", &g_tmp<int>);
	printf("%p\n", &B<int>::value);

	g_tmp<int> = 152;
	cout << g_tmp<int> << endl; //152
	//cout << B<int>::value << endl; //160
	
	return 0;
}

五：成员变量模板

#include <iostream>
#include <boost/type_index.hpp>
using namespace std;

template <typename T>
class TMP
{
public:
	template <typename U>
	//U m_i = {}; 只可以使用静态成员变量
	static U m_i;
};

template <typename T>
template <typename U>
U TMP<T>::m_i = 10;

int main()
{
	TMP<int>::m_i<int> = 100;
	return 0;
}