C++初阶 —— 模板进阶

关注

原创 2024-11-13 17:45:03 1.1k 阅读 AI 写同款· GEO 优化 ›

c++中的enum类型 C++允许程序员创建自己的数据类型，比如本节要将的枚举类型。枚举数据类型是一种由程序员定义的数据类型，其合法值是与它们关联的一组命名整数常量。之所以被称为枚举类型，就是因为命名常量是作为数据类型定义的一部分而枚举或列出的，以下是枚举类型声明的示例： enum Roster {Tom, Sharon, Bill, Teresa, John}; 该语句将创建一个名为 Roster 的数据类型。... 阅读详情

一，非类型模板参数

模板参数分类

类型形参，模板参数列表中，在class/typename后的名称；
非类型形参，使用一个常量作为类或函数模板的一个参数，可将此参数当成常量使用；

template<class T, size_t N=10> //T为类型参数，N为非类型参数
class array
{
public:
	size_t size()
	{
		return sizeof(_array) / sizeof(T);
	}	
private:
	T _array[N];
};

int main()
{
	array<char>arr;
	std::cout << arr.size() << std::endl;
	return 0;
}

注：

非类型形参，可以是整数、枚举、指向objects/function/members的指针或者引用，也可以是常量表达式；
浮点数、类对象、及字符串是不允许作为非类型模板参数的；
非类型模板参数必须在编译期就能确认结果，不能被修改，也不能作为左值；

//enum color 为传统枚举类型，全局命名空间，会隐式类型转换为整形；
//enum class color C++11引入的新类型，将枚举限定在一个作用域内，且不会隐式转换为整形；
enum class color
{
	red, green, blue
};

void func()
{
	cout << "func" << endl;
}

class Ref
{
public:
	void print() { cout << "class ref" << endl; }
}f;

template<class T, color c, void(*func)(), Ref& r>
class A
{
public:
	void print() 
	{ 
		printf("T _a = %c\n", _a);
		printf("int _b = %d\n", _b);
		printf("int _p = %p\n", _p);
		_r.print();
	}
private:
	T _a = 'a';
	int _b = static_cast<int>(c);
	int* _p = (int*)func;
	Ref _r = r;
};

int main()
{
	A<char, color::blue, func, f> a;
	a.print();
	return 0;
}

二，模板特化

通常，使用模板可实现与类型无关的代码，但对一些特殊的类型可能会得到错误的结果，此时需对模板进行特化，即在原模板类的基础上，针对特殊类型进行特殊化实现的方式；

template<class T>
bool IsEqual(const T& left, const T& right)
{
	return left == right;
}

int main()
{
    //实参为整数，调用IsEqual没问题
	cout << IsEqual(1, 1) << endl;

    //实参为指针，调用IsEqual实际上是指针的比较
	const char p1[] = "ab";
	const char p2[] = "ab";
	cout << IsEqual(p1, p2) << endl;
	return 0;
}

template<class T>
bool IsEqual(const T& left, const T& right)
{
	return left == right;
}

//优先匹配现成的
bool IsEqual(const char* left, const char* right)
{
	return strcmp(left, right) == 0;
}

int main()
{
	cout << IsEqual(1, 1) << endl;

	const char p1[] = "ab";
	const char p2[] = "ab";
	cout << IsEqual(p1, p2) << endl;
	return 0;
}

函数模板特化

必须先有一个基础的函数模板；
关键字template后面接<>；
函数名后需接<>，其内指定特化类型；
函数形参列表，必须要和模板函数的基础参数类型完全相同；

//模板特化
//const char* const，第一个const修饰指针指向的对象，第二个const修饰指针本身
template<>
bool IsEqual<const char* const >(const char* const& left, const char* const& right)
{
	return strcmp(left, right) == 0;
}

//如函数模板遇到不能处理或处理有误的类型，可直接将该函数给出
bool IsEqual(char* left, char* right)
{
	return strcmp(left, right) == 0;
}

类模板特化

全特化，即将模板参数列表中所有参数都特化；
偏特化或半特化，部分参数特化、或参数更进一步限制；

//类模板
template<class T1, class T2>
class Data
{
public:
	Data(){cout << "Data<T1, T2>" << endl;}
private:
	T1 _d1;
	T2 _d2;
};

//类模板特化，全特化
template<>
class Data<int, double>
{
public:
	Data(){cout << "Data<int, double>" << endl;}
private:
	int _d1;
	double _d2;
};

//类模板偏特化
template<class T1>
class Data<T1, double>
{
public:
	Data(){cout << "Data<T1, double>" << endl;}
private:
	T1 _d1;
	double _d2;
};

//参数偏特化为指针类型
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
	Data(){cout << "Data<T1*, T2*>" << endl;}
private:
	T1 _d1;
	T2 _d2;
};

//参数偏特化为引用类型
template<class T1, class T2>
class Data<T1&, T2&>
{
public:
	Data(){cout << "Data<T1&, T2&>" << endl;}
private:
	T1 _d1;
	T2 _d2;
};

三，模板分离编译

程序在计算机中的执行过程：

分离编译

一个程序或项目由若干个源文件共同实现，每个源文件单独编译生成目标文件，最后将所有目标文件链接生成单一的可执行文件的过程；

模板不可分离编译（即在头文件声明，源文件定义），此时会报链接错误；

//头文件add.h
template<class T>
T add(const T& a, const T& b);

//源文件add.cpp
template<class T>
T add(const T& a, const T& b)
{
	return a + b;
}

//源文件main.cpp
#include "head.h"
#include<iostream>
int main()
{
	std::cout << add(1, 2) << std::endl;;
	return 0;
}

链接失败原因

源文件add.cpp/main.cpp，分别独立编译最后生成add.obj/main.obj，而在main.cpp中并没有add函数的实现，所以main.obj中仅有一条call指令(声明调用add函数，此时无实际调用地址)，将add当成外部链处理(即认为此函数实现代码在另一个.obj文件中)；
在链接时，指定call指令后调用add的地址，来实现调用；模板函数是不能直接编译成代码，需实例化才可，但add.cpp中，并没有用到模板函数，也就没有实例化(C++标准规定)，也就没有add实现地址；

注：在分离编译环境下，源文件都是独立编译的，编译器并不知道其他源文件的存在，对于函数的调用只能靠链接器；在普通函数情况下没有问题，但遇到模板时就会容易导致链接错误，因为模板仅在需要时才会实例化；当编译器遇到模板声明时，不会实例化模板仅常见具有外部链接的符号期待链接时能够得到符号的地址；

解决方法

将声明和定义放在同一个.h(.hpp)文件中；
在模板定义的文件中，显示实例化，此方法不推荐；

//头文件add.h
template<class T>
T add(const T& a, const T& b);

template<class T>
T add(const T& a, const T& b)
{
	return a + b;
}

//源文件add.cpp
template<class T>
T add(const T& a, const T& b)
{
	return a + b;
}

//显示实例化
//缺点是用一个类型就需实例化一个类型
template
int add(const int& a, const int& b);

//或
template<>
int add(const int& a, const int& b)
{
	return a + b;
}

注：模板是按需实例化的，没有实例化编译器不会检测模板内部语法错误，对类模板的成员函数也是按需实例化的，即调用时才实例化；