C++之模板

不是我衰

已于 2023-11-16 23:32:48 修改

阅读量65

点赞数

分类专栏： C++ 文章标签： c++ 算法数据结构

于 2023-10-13 20:20:12 首次发布

本文链接：https://blog.csdn.net/ZZY5707/article/details/132806441

版权

C++ 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

泛型编程

如何实现一个通用的交换函数呢？

即我们想交换两个变量，这两个变量可以是整型，也可以是浮点型，或者其它内置类型，然后它们的交换都可以用一个函数完成。那在C语言中肯定是没法解决这个问题的，但C++里支持函数重载，所以可以这样：
void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}
void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}
void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}
//..
使用函数重载虽然可以实现，但是有一下几个不好的地方：
1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。
2. 代码的可维护性比较低，一个出错可能所有的重载均出错，那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会方便很多。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板初阶

函数模板

函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

函数模板格式

template<typename T1, typename T2,......,typename Tn>
返回值类型函数名(参数列表){}
template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main()
{
    int x1 = 1, x2 = 2;
    double y1 = 1.0, y2 = 2.0;
    Swap(x1,x2);
    Swap(y1,y2);
    return 0;
}

但是如果出现两个参数类型不同的情况:

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main(void)
{
    int a = 10;
    double b = 20.0;
    Swap(a, b);//编译报错
    return 0;
}

该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a将T推演为int，通过实参b将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作。

解决方法：

1. 用户自己来强制转化

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main(void)
{
    int a = 10;
    double b = 20.0;
    Swap((double)a, b);
    Swap(a, (int)b);
    return 0;
}

2. 使用显式实例化:如下

2.显式实例化：在函数名后的<>中指定模板参数的实际类型

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main(void)
{
    int a = 10;
    double b = 20.0;
// 显式实例化
    Swap<int>(a, b);
    Swap<double>(a, b);
    return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

还有一些场景只能显示实例化：
template<typename T>
T* func(int n)
{
	return new T[n];
}
int main()
{
    int* ptr = func<int>(10);
    return 0;
}
参数中没有T类型的形参，无法隐式实例化推出模板参数的实际类型，只能显示实例化。

注意：上面的Swap(x1, x2)和Swap(y1, y2)调用的是同一个函数吗？

调用汇编发现，两次call的函数地址是不一样的，并不是同一个函数。函数建立栈帧，它们的参数类型都不一样，那建立的栈帧都不一样大，怎么会是同一个函数呢。

模板参数的匹配原则

1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非模板函数匹配，编译器不需要特化
    Add<int>(1, 2); // 调用编译器特化的Add版本
}

2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
/ 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函
数
}

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

类模板

如果不使用类模板，一般我们会使用typedef，这样如果我们想改变栈里存储数据的类型，就比较方便了。

typedef int DataType;
class Stack
{
public:
	//构造函数
	Stack(size_t capacity = 4)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
    Stack s1;//int
    Stack s2;//double
}
如果我们在main函数里定义了2个或者多个栈，想让它们分别存储不同类型的数据，显然是没法做到的，现在是int，那它们两个里面就都只能存int，如果我们改成double，那就都只能存double。如果想做到，那就只能定义两个栈的类，一个int的，一个double的。但是这样它们除了数据类型不一样，其它都一样啊。这种重复的事情就可以交给编译器去做。

类模板的定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};

template<class T>
class Stack
{
public:
	Stack(int capaicty = 4)
	{
		_a = new T[capaicty];
		_top = 0;
		_capacity = capaicty;
	}

	~Stack()
	{
		delete[] _a;
		_capacity = _top = 0;
	}

private:
	T* _a;
	size_t _top;
	size_t _capacity;
};
要注意的是：
类模板实例化与函数模板实例化有些不同，类模板实例化只能显式实例化，即需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可。因为函数模板实例化可以根据参数类型去推演模板参数的类型，但是我们拿一个类去创建对象，就比如当前的栈，不会直接传数据类型是什么，所以要显式实例化:
int main()
{
    Stack<int> s1;
    Stack<double> s2;
    return 0;
}
Stack是类名，Stack<int>才是类型。这样我们就可以让不同的栈对象里面存不同类型的数据了。

注意：类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

还需要注意的是： 类模板中成员函数放在类外进行定义时，需要加模板参数列表

以析构函数为例：

template<class T>
class Stack
{
public:
	Stack(int capaicty = 4)
	{
		_a = new T[capaicty];
		_top = 0;
		_capacity = capaicty;
	}

	~Stack();


private:
	T* _a;
	size_t _top;
	size_t _capacity;
};
//类名: Stack
//类型: Stack<T>
//错误的定义
//Stack::~Stack()
//{
//    //..
//}

template<class T>
Stack<T>::~Stack()
{
	delete[] _a;
	_capacity = _top = 0;
}

模板进阶

模板参数的分类

类型模板参数

之前定义模板参数使用的是class或者typename关键字，

template<class T1, class T2,...,class Tn>

template<typename T1, typename T2,...,typename Tn>

对于参数中有模板参数的函数模板来说，我们调用函数时，传的参数是什么类型，T就会被替换成对应的类型，然后实例化出对应的模板函数，我们实际调用的就是函数模板根据具体传入的实参类型实例化出来的模板函数。

对于跟在class或者typename之后的这种模板参数，我们把它叫做类型模板参数：

它定义的是一个类型，对应的模板实例化的时候该参数会被替换成一个具体的类型，供其对应的模板类或模板函数使用。

但其实模板参数分为类型模板参数和非类型模板参数。

类型模板参数已经了解了,

类型模板参数:出现在模板参数列表中,跟在class或者typename关键字之后的参数类型名称。

那非类型模板参数又是什么呢？

非类型模板参数

非类型模板参数的引入

首先对于类型模板参数来说，他解决了类型的问题。
没有学模板之前，比如写一个顺序表，我们一般会有一个

typedef 存储的类型 Datatype

这样想要改变栈里存储的数据的类型很方便，但是如果我们在main函数里定义了2个或者多个顺序表并且想让它们分别存储不同类型的数据，如果typedef的话是不能的，但是有了模板的话，用类型模板参数就可以解决这个问题.

#define N 10
template <class T>
class Array
{
public:
	//..
private:
	T a[N];
};

int main()
{
	Array<int> a1;
	Array<double> a2;
	return 0;
}

存储不同类型的效果实现了,但是现在如果我们想让a1的大小为10 ，而a2的大小为20，目前的实现可以做到吗？
不行啊，虽然这里我们用来#define定义的宏，改变数组的大小是很方便的，但是，这里我们实例化出两个对象，一个大小为10，一个20，是不是做不到啊,那就可以使用非类型模板参数

非类型模板参数的概念：

非类型模板参数，就是用一个常量（且必须是整型常量）作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

注意：这里的整型不单指int，而是整个整型家族（包括C99引入的bool类型）

非类型模板参数的使用

template <class T,size_t N>
class Array
{
public:
	//..
private:
	T a[N];
};

和类型模板参数一样，直接放在模板参数列表里面就行了。
我们看到这里是这样写的——size_t N，虽然没加const，但是规定它在这里就是常量。

int main()
{
	Array<int,10> a1;
	Array<double,20> a2;
	return 0;
}

运行结果:

非类型模板参数也是可以给缺省值的:

template <class T,size_t N = 10>
class Array
{
public:
	//..
private:
	T a[N];
};

int main()
{
	Array<int> a1;
	Array<double> a2;
	return 0;
}

注意:非类型模板参数必须是常量且要是整型,不可被修改。

不能传变量:

不能是非整型类型参数:

浮点数、类对象以及字符串等其它非整形的类型是不允许作为非类型模板参数的。
不过C++20允许使用float或double作为非类型模板参数。

不能修改:

array简单介绍

C++11出来了一个新容器——array。
其实可以认为就是静态数组，我们看到文档给的解释是固定大小的序列容器

array这个类模板用了一个非类型模板参数来作为这个数组的大小。

成员函数:

C++11搞出来这个东西其实是对标C语言里的静态数组,我们包一下<array>这个头文件就可以使用它,那array的底层其实也是一个静态数组，只不过用类进行了封装。

#include <array>
#include <iostream>
using namespace std;
int main()
{
	int a1[20] = { 0 };
	array<int, 20> a2;
	cout << "a1:"<<sizeof(a1) <<endl<< "a2:" << sizeof(a2);
	return 0;
}

可以看到大小都是一样的:

array支持迭代器for循环:

void test_array2()
{
	array<int, 20> a;
	array<int, 20>::iterator it = a.begin();
	for (int i = 0; i < 20; i++)
	{
		a[i] = i;
	}

	for (auto& e : a)
	{
		cout << *it << " ";
		it++;
	}

}

它的主要优势是对越界的一个检查比数组更严格一点。传统的数组对于越界的检查是一个抽查，有时候越界会报错，而有时候可能就不会

C语言数组越界读不会报错,越界写就会报错:

void test_array3()
{
	int arr[10] = { 0 };
	for (int i = 0; i <=10; i++)
	{
		cout << arr[i] <<" ";
	}
}

int main()
{
	test_array3();

	return 0;
}

void test_array3()
{
	int arr[10] = { 0 };
	for (int i = 0; i <=10; i++)
	{
		arr[i] = i;
		cout << arr[i] <<" ";
	}
}

int main()
{
	test_array3();

	return 0;
}

它对于读写的检查就比较严格，比较全面,读写都会报错:

void test_array4()
{
	array<int, 10> arr;
	for (int i = 0; i <= 10; i++)
	{
		arr[i] = i;
	}
}

int main()
{
	test_array4();

	return 0;
}

C++11出来这个array其实是想让我们以后用数组的时候都用array。
但是vector如果越界也能很好的检查啊，并且vector还能直接初始化，如果要论array和vector的区别的话，那就是array的空间是在栈上开辟的，而vector的空间是在堆上申请的。

所以array用的其实并不多.

模板的特化

概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。

现在有一个专门用来进行小于比较的函数模板,现在用它去比较不同类型数据的大小：

template<class T>
bool Less(T left, T right)
{
    return left < right;
}

int main()
{
    cout << Less(1, 5) << endl; // 可以比较，结果正确
    return 0;
}

现在我们拿过来一个日期类,且重载了 > < 运算符:

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}
	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}
private:
	int _year;
	int _month;
	int _day;
};

void test_template1()
{
	Date d2(2023, 10, 14);
	Date d1(2023,10,13);
	cout << Less(d1, d2)<<endl;
	
	Date* p2 = &d2;
	Date* p1 = &d1;
	cout << Less(p1, p2) << endl;
}

int main()
{
	test_template1();
	return 0;
}

p1指向的日期小于p2指向的日期啊，那结果怎么是0呢?

因为这里比较的并不是它们指向的日期，而是这两个指针本身，那指针进行比较的话实际比较的是它们存储的地址的大小，所以这里的结果可能并不是我们想要的。
可以看到，Less大多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。
上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

除了仿函数,也可以使用函数模板特化去解决这个问题。

模板特化:

模板特化即在原模板的基础上，针对特殊类型所进行特殊化的实现。
模板特化中分为函数模板特化与类模板特化。

函数模板特化

那现在问题来了，对于一个像上面那样的函数模板，我们想对其进行特化，要怎么做呢？

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

void test_template1()
{
	Date d2(2023, 10, 14);
	Date d1(2023,10,13);
	//cout << Less(d1, d2)<<endl;

	Date* p2 = &d2;
	Date* p1 = &d1;
	cout << Less(p1, p2) << endl;
}

1.必须要先有一个基础的函数模板

2.关键字template后面接一对空的尖括号<>

3.函数名后跟一对尖括号，尖括号中指定需要特化的类型

4.函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

void test_template1()
{
	Date d2(2023, 10, 14);
	Date d1(2023,10,13);
	//cout << Less(d1, d2)<<endl;

	Date* p2 = &d2;
	Date* p1 = &d1;
	cout << Less(p1, p2) << endl;
}

int main()
{
	test_template1();
	return 0;
}

模板特化就是针对某些特殊类型进行特殊化的处理。

实现了特化之后：

对于那些普通的类型，就还是走普通版本的逻辑, 而一旦遇到我们特化的类型，它就会走特化版本的逻辑,但是看上去是这样,其实并不完全是,有的时候也不会走函数特化.

template<class T>
bool Less(T left, T right)
{
	cout << "Less(T left, T right)" << endl;
	return left < right;
}

template<>
bool Less<Date*>(Date* left, Date* right)
{
	cout << "Less<Date*>(Date* left, Date* right)" << endl;
	return *left < *right;
}

template<class T>
bool Less(T* left, T* right)
{
	cout << "Less(T* left, T* right)" << endl;
	return *left < *right;
}

void test_template1()
{
	Date d2(2023, 10, 14);
	Date d1(2023,10,13);
	//cout << Less(d1, d2)<<endl;

	Date* p2 = &d2;
	Date* p1 = &d1;
	cout << Less(p1, p2) << endl;
}

int main()
{
	test_template1();
	return 0;
}

这里又实现了一个函数模板(可以说是函数模板重载),函数的类型模板参数是T*,可以看到即使实现了特化编译器也并不会先去用特化,而是先在模板里找是否有匹配的参数.

所以建议直接使用函数重载:

template<class T>
bool Less(T left, T right)
{
	cout << "Less(T left, T right)" << endl;
	return left < right;
}

bool Less(Date* left, Date* right)
{
	cout << "Less(Date* left, Date* right)" << endl;
	return *left < *right;
}

void test_template1()
{
	Date d2(2023, 10, 14);
	Date d1(2023,10,13);
	//cout << Less(d1, d2)<<endl;

	Date* p2 = &d2;
	Date* p1 = &d1;
	cout << Less(p1, p2) << endl;
}

int main()
{
	test_template1();
	return 0;
}

这种实现简单明了，代码的可读性高，容易书写。

所以说：

函数模板不建议特化，一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将处理该情况的函数直接给出，而不是对其进行特化。

类模板特化

类模板的特化：

首先我们要知道模板的特化其实分为两种——全特化和偏特化。

全特化

全特化: 将模板参数列表中所有的参数都确定化。(上面函数模板的特化其实就是全特化,且函数模板没有偏特化)

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

现在想对这个类模板进行全特化，怎么做呢？

template<>
class Data<int ,char>
{
public:
	Data()
	{
		cout << "Data<int, char>" << endl;
	}
private:
	int x;
	char y;
};

和函数模板特化类似:

1.必须要先有一个基础的类模板

2.关键字template后面接一对空的尖括号<>

3.类名后跟一对尖括号，尖括号中指定需要特化的类型

4.模板参数表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

void test_template()
{
	Data<int, char> d1;
	Data<int, int> d2;
}
int main()
{
	test_template();
	return 0;
}

偏特化

那什么是偏特化呢？偏特化有以下两种表现方式：

部分特化

部分特化:将模板参数类表中的一部分参数特化（确定化）

我们想对它进行部分特化，比如把第二个参数特化成int

template<class T1>
class Data<T1,int>
{
public:
	Data()
	{
		cout << "Data<int, char>" << endl;
	}
private:
	T1 x;
	int y;
};

void test_template()
{
	Data<char, char> d0;//走原来的类模板
	Data<int, char> d1;//全特化
	Data<int, int> d2;//偏特化
}
int main()
{
	test_template();
	return 0;
}

参数更进一步的限制

参数更进一步的限制:针对模板参数更进一步的条件限制所设计出来的一个特化版本。

template<class T>
struct Less
{
	bool operator()(const T& l, const T& r) const
	{
		return l < r;
	}
};

我们来用它比较一些内置类型数据的大小，包括我们的日期类（重载了><）。如果我们比Date*的话，还是比较的是地址的大小，如果我们想让他比较指针指向的数据的大小，我们可以对Date* 这个类型进行一个全特化。

template<class T>
struct Less
{
	bool operator()(const T& l, const T& r) const
	{
		return l < r;
	}
};

template<>
struct Less<Date*>
{
	bool operator()(const Date* l, const Date* r)
	{
		return *l < *r;
	}
};

void test_template()
{
	Date d1(2023, 10, 13);
	Date d2(2023, 10, 14);
	Date* p1 = &d1;
	Date* p2 = &d2;

	cout << Less<Date*>()(p1,p2)<< endl;
}

int main()
{
	test_template();
	return 0;
}

但是，如果我们不只针对Date*的指针，对于其它类型的指针，比较时我们也想去比较它们指向的内容，而不是地址。

那我们可以怎么做呢？难道对不同的指针类型都进行一个特化吗？

这显然是很麻烦的。
那我们此时就可以用偏特化的第二种形式——参数更进一步的限制来解决这个问题。

template<class T>
struct Less
{
	bool operator()(const T& l, const T& r) const
	{
		return l < r;
	}
};

template<class T>
struct Less<T*>
{
	bool operator()(T* l, T* r)
	{
		return *l < *r;
	}
};

void test_template()
{
	Date d1(2023, 10, 13);
	Date d2(2023, 10, 14);
	Date* p1 = &d1;
	Date* p2 = &d2;

	cout << Less<Date*>()(p1,p2)<< endl;

	int a = 1, b = 2;
	int* pa = &a;
	int* pb = &b;
	cout<< Less<int*>()(pa, pb) << endl;
}

进行一个偏特化，将模板参数限制成T*，这样只要调用仿函数时传的数据是指针类型，都会去匹配偏特化的这个版本，对指针指向的内容进行比较，而不是存储的地址。

仅个人理解: 这种参数的进一步限制可以形象的理解成类模板的重载(但它还是偏特化,因为类模板不能重载但是函数模板可以重载,从下面的匹配优先级可以看出来) , 而且全特化和部分偏特化不叫重载可以理解为它们的模板参数类型都有一个确定的类型了,叫特化更形象

匹配的优先级

对于函数模板、函数模板的(全)特化, 以及同名普通函数都存在的情况下，编译器在编译阶段进行匹配时，只匹配普通函数和模板, 匹配顺序如下:
1. 查找普通函数中有没有匹配的,如果有就选它
2. 查找模板和模板重载中有没有匹配的, 并选择最匹配的版本, 然后进行3

注意, 上面规则没提到特化版本,如果规则2也就是模板都不匹配, 然后才进行特化版本的匹配

3. 查找全特化版本中有没有匹配的

函数模板没有偏特化,就直接查找全特化,类模板先查找全特化再查找偏特化

特化版本不参与重载的原因是C＋＋委员会认为因为写了一个特化版本而使得原先的重载函数模板匹配结果发生改变是不能接受的.

由于函数模板特化后的匹配行为很容易让人迷惑, 实际中不推荐使用函数模板的特化, 而选择使用普通函数!

对于函数模板: 普通函数 > 更符合的模板(函数模板重载) > (全)特化 > 最初的模板

对于类模板 : 全特化 > 偏特化 > 模板

注意:类模板不能重载,函数模板可以重载

走了全特化

有合适的模板就去用合适的模板了,不走特化

如果再重载一个普通函数,那就会去调用普通函数,模板就不看了,这里不演示了

不是我衰

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++之模板

class 类模板名// 类内成员定义public:_top = 0;类模板实例化与函数模板实例化有些不同，类模板实例化只能显式实例化，即需要在类模板名字后跟，然后将实例化的类型放在中即可。Stack是类名，Stack才是类型。这样我们就可以让不同的栈对象里面存不同类型的数据了。
复制链接

扫一扫

专栏目录