528-C++重点(函数模板,类模板)

青旅半醒 2022-09-10 13:10 237阅读 0赞

## C++ 函数模板 ##

**一般使用在开发库中**

**模板的意义：对类型也可以进行参数化了**

**可以定义多个类型参数，中间用逗号隔开**  
![在这里插入图片描述][9c8925c2b11446c59e00a303a082b64c.png]  
**也可以用关键字class替代typename**  
![在这里插入图片描述][5b1d423aacd74c4bbe402a1507d0244e.png]  
![在这里插入图片描述][3a834187b44c4890904631e873467d1c.png]  
**我们看下面代码**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]  
compare只是一个模板函数名称。我们调用这个compare的时候，肯定是希望这个是函数名称。  
**模板名加上参数列表才是函数名称**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
![在这里插入图片描述][6b70b4964e664de4b5f2474cbab3edbb.png]  
**在函数调用点，编译器用用户指定的类型，从原模板实例化一份函数代码出来模板函数如下**

bool compare<int>(int a, int b)
    {
        
    	return a > b;
    }

**如果我们又去调用一个compare的时候，double类型的。**  
![在这里插入图片描述][dc6115dd824949d09c2911b81f1ca630.png]  
**在调用点，编译器又会用double去实例化一份函数代码出来模板函数如下**

bool compare<double>(double a, double b)
    {
        
    	return a > b;
    }

**模板的好处是**  
**我们用户**只用写一套代码实现逻辑就可以了，至于用什么类型，模板最终用什么类型实例化，我们可以在调用的地方去指定类型，编译器就会从原模板用指定的类型去实例化代码出来。  
**对于编译器来说，需要待编译的函数并没有减少，每个类型都对应一份函数。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
**只用函数模板的名字，我们也可以进行函数的调用**  
![在这里插入图片描述][83ea6ab5e4464d88a5b5f5da64e3c854.png]  
**这是因为 模板的实参推演 => 可以根据用户传入的实参的类型，来推导出模板类型参数的具体类型**  
**注意**：不会再生成和之前生成的模板函数一模一样的函数，不然就成函数的重定义了，会产生符号，每个模板函数的符号只能出现一次，每种模板函数只产生一份，下次需要调用就直接调用之前产生的那个对应的模板函数就可以了

**下面这种情况是什么样的？**  
![在这里插入图片描述][d77c4bd7ebf348c7932d5fc76f371349.png]  
通过第一个传入的实参，推导出T是int整型，通过第二个传入的实参，推导出T是double型，那么T到底是int还是double呢？？？  
![在这里插入图片描述][7fd944ba337049c3b25617876f791051.png]  
编译器推导不出来。  
**解决方法**：另外定义一个新的模板类型参数，a和b用不同的模板类型参数。  
我们还可以指定模板类型是int，第一个实参是整型，就传给整型，第二个实参是double，就把double转换成int整型带进去。  
![在这里插入图片描述][becefb51753541399df93a7ec57717ca.png]  
![在这里插入图片描述][3a7bc4bb75d341bfb19bf09195c9ea23.png]  
**函数模板：** 是无法编译的。因为不知道T的类型是什么，无法编译。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
**函数模板 <= 是不进行编译的，因为类型还不知道  
模板的实例化 <= 函数调用点进行实例化  
模板函数 <= 才是要被编译器所编译的**

![在这里插入图片描述][89055a024f044cc38d334c9d6242edba.png]  
假设现在我们要比较两个字符串。  
![在这里插入图片描述][a4b8f5dd2caa4089952498bcc32d5391.png]  
也是可以比较的  
但是，我们在调用这个模板的时候，并没有指定这个参数列表，它就得进行函数模板实参的推演，通过实参推导出T是const char\*  
得到的实例化的模板函数是：

bool compare<const char*>(const char* a, const char* b)
    {
        
    	return a>b;
    }

显然这是在比较两个字符串的地址的大小，没有意义啊。  
我们肯定是想比较它们的字典顺序。  
**实际上，应该调用**

bool compare<const char*>(const char* a, const char* b)
    {
        
    	return strcmp(a, b) > 0;
    }

**但是编译器没有办法，因为模板给的是a>b，它只能用你指定的或者推导出来的类型来确定类型，并不能根据具体的类型来改变你的代码。**  
对于某些类型来说，依赖编译器默认实例化的模板代码，代码处理逻辑是有错误的

这时候怎么办？  
我们需要给模板提供特例化了。  
**模板的特例化(专用化) 特殊（不是编译器提供的，而是用户提供的）的实例化**  
先有模板，才能模板特例化哦  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
![在这里插入图片描述][68e21c1f7c8e4c20883998a763f8a622.png]  
**当然，我们的代码还可以出现这样的操作**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
**函数模板、模板的特例化、非模板函数的重载关系**  
**现在进行调用这个代码的话，编译器优先看成是函数名！**  
![在这里插入图片描述][cd50fbb2f20c4bdca726617d9956d8a1.png]  
**调用的是普通的非模板函数**  
![在这里插入图片描述][68158f3db61f44daab1c9fe65bf6cb70.png]  
但是，如果是写出下面这样的形式  
![在这里插入图片描述][a0ee3d30d4c14455a75a7e0fe4858a04.png]  
编译器无论如何不能把compare当成函数名了，因为函数名后面是不能加<>的，只有模板名的后面才可以加<>  
所以，这时编译器就去看compare模板，刚要实例化模板，看到用户已经自定义特例化版本了，就直接用特例化。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 6]  
![在这里插入图片描述][ab573b1541d8454e824e281e2a0d51cd.png]

//函数模板实参的推演 T const char*
    	//对于某些类型来说，依赖编译器默认实例化的模板代码，代码处理逻辑是有错误的
    	//编译器优先把compare处理成函数名字，没有的话，才去找compare模板
    	compare("aaa", "bbb");
    	compare<const char*>("aaa", "bbb");

**我们再看，我们在写多文件的时候，要注意：**  
我们在一个文件中定义模板，在另一个文件中声明模板，然后使用它。  
会发生链接错误  
![在这里插入图片描述][540b932d2bc64496812e7bd455b03251.png]  
**找不到相应的符号**  
![在这里插入图片描述][e38964ba885245d6b7186e83be777fb6.png]  
**我们把int，double的调用模板代码屏蔽掉，是可以调用特例化的。**

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 7]  
**我们把自定义的普通函数也声明一下。**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 8]  
**模板代码是不能在一个文件中定义，在另外一个文件中使用的  
模板代码调用之前，一定要看到模板定义的地方，这样的话，模板才能够进行正常的实例化，产生能够被编译器编译的代码**

**所以，模板代码都是放在头文件当中的，然后在源文件当中直接进行\#include包含**

**include是在预编译的过程中，把头文件的代码直接在当前源文件中展开**

**如果一定要在多个文件调用，还是有办法的。**  
![在这里插入图片描述][af68bf2961584c599b571c52c080f89d.png]

**不用看调用点，直接用用户指定的类型进行模板实例化。**  
![在这里插入图片描述][9ff381f8797f47b8832099ae8b944f20.png]  
**模板的非类型参数**  
必须是整数类型（整数或者地址/引用都可以）  
都是常量，只能使用，而不能修改

template<typename T, int SIZE>
    void sort(T *arr)
    {
        
    	for (int i = 0; i < SIZE - 1; ++i)
    	{
        
    		for (int j = 0; j < SIZE - 1 - i; ++j)
    		{
        
    			if (arr[j] > arr[j + 1])
    			{
        
    				int tmp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = tmp;
    			}
    		}
    	}
    }
    int main()
    {
        
    	int arr[] = {
         12,5,7,89,32,21,35 };
    	const int size = sizeof(arr) / sizeof(arr[0]);//常量表达式 
    	sort<int, 7>(arr);
    	for (int val : arr)
    	{
        
    		cout << val << " ";
    	}
    	cout << endl;
    	return 0;
    }

![在这里插入图片描述][9b23376bd2c44e4fb7773bf280728d78.png]

## C++类模板 ##

**模板类实现顺序栈**  
类模板 => 实例化 => 模板类

//类模板
    template<typename T>
    class SeqStack//模板名称+类型参数列表 = 类名称
    {
        
    public:
    	//构造和析构函数名不用加<T>，其它出现模板的地方都加上类型参数列表
    	SeqStack(int size = 10)
    		: _pstack(new T[size])
    		, _top(0)
    		, _size(size)
    	{
        }
    	~SeqStack()
    	{
        
    		delete[]_pstack;
    		_pstack = nullptr;
    	}
    	SeqStack(const SeqStack<T> &stack)
    		:_top(stack._top)
    		,_size(stack._size)
    	{
        
    		_pstack = new T[_size];
    		//不要用memcopy进行拷贝
    		for (int i = 0; i < _top; ++i)
    		{
        
    			_pstack[i] = stack._pstack[i];
    		}
    	}
    	SeqStack<T>& operator=(const SeqStack<T> &stack)
    	{
        
    		if (this == &stack)
    			return *this;
    
    		delete[]_pstack;
    
    		_top = stack._top;
    		_size = stack._size;
    		_pstack = new T[_size];
    		//不要用memcopy进行拷贝
    		for (int i = 0; i < _top; ++i)
    		{
        
    			_pstack[i] = stack._pstack[i];
    		}
    		return *this;
    	}
    
    	void push(const T &val);//入栈操作
    
    	void pop()//出栈操作
    	{
        
    		if (empty())
    			return;
    		--_top;
    	}
    	T top()const//返回栈顶元素
    	{
        
    		if (empty())
    			throw "stack is empty!";//抛异常也代表函数逻辑结束
    		return _pstack[_top - 1];
    	}
    	bool full()const {
         return _top == _size; }//栈满
    	bool empty()const {
         return _top == 0; }//栈空
    private:
    	T *_pstack;
    	int _top;
    	int _size;
    
    	//顺序栈底层数组按2倍的方式扩容
    	void expand()
    	{
        
    		T *ptmp = new T[_size * 2];
    		for (int i = 0; i < _top; ++i)
    		{
        
    			ptmp[i] = _pstack[i];
    		}
    		delete []_pstack;
    		_pstack = ptmp;
    		_size *= 2;
    	}
    };
    template<typename T>//类外实现，还要再写这个哦，因为这个类模板作用域到{开始 }结束了 
    void SeqStack<T>::push(const T &val)//入栈操作
    {
        
    	if (full())
    		expand();
    	_pstack[_top++] = val;
    }
    
    int main()
    {
        
    	//类模板的选择性实例化
    	//实例化后 产生模板类 class SeqStack<int>{};
    	SeqStack<int> s1;//编译器到达这个调用点，会把模板实例化一份专门处理int的类出来 
    	//到这个点生成的模板类只有构造函数和析构函数，其他的方法等被对象调用了才被实例化出来 
    	//减少编译器的工作 
    	s1.push(20);
    	s1.push(78);
    	s1.push(32);
    	s1.push(15);
    	s1.pop();
    	cout << s1.top() << endl;
    
    	SeqStack<> s2;
    
    	return 0;
    }

**类模板还可以加默认的类型参数**  
![在这里插入图片描述][34169f97638b485393ecd9d56a028e95.png]  
**就可以这样去使用它**  
![在这里插入图片描述][2c350f7735e34f49b269bdd164e923e8.png]

[9c8925c2b11446c59e00a303a082b64c.png]: /images/20220829/e16c5682c7464e32b7e0a7a67959fc8c.png
[5b1d423aacd74c4bbe402a1507d0244e.png]: /images/20220829/da1fd33328b0452da6d83deebe870ae4.png
[3a834187b44c4890904631e873467d1c.png]: /images/20220829/aea97a52096b490e8d86f87bee7e782a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/baf6f6ab4cfc4b6bbce83f4e8237c421.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/dea623e80a714317b33f1f4f05c56e28.png
[6b70b4964e664de4b5f2474cbab3edbb.png]: /images/20220829/2747b87f9faf47eb969af616d5211faa.png
[dc6115dd824949d09c2911b81f1ca630.png]: /images/20220829/845b915059c749a78718413f7cd98400.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/7a8fb2940eff47e48a0a4a689a91b03f.png
[83ea6ab5e4464d88a5b5f5da64e3c854.png]: /images/20220829/0c551916978642d5b0c62181ac60615b.png
[d77c4bd7ebf348c7932d5fc76f371349.png]: /images/20220829/43174422798b4b9a87c725969c80408e.png
[7fd944ba337049c3b25617876f791051.png]: /images/20220829/dd95cd91b4b04fa1add2bcdf5b76a97b.png
[becefb51753541399df93a7ec57717ca.png]: /images/20220829/ac2ddf6148714fc4807ac2ed8357763a.png
[3a7bc4bb75d341bfb19bf09195c9ea23.png]: /images/20220829/b45140291e0a4e05901e5b983f495f14.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/e1477861e0c7487a9ce2781aeccc28bc.png
[89055a024f044cc38d334c9d6242edba.png]: /images/20220829/eb5361a0a06b41c7a771ca00c558e819.png
[a4b8f5dd2caa4089952498bcc32d5391.png]: /images/20220829/6a3ac57a66cc4cb0b0cfc59287ef0a2c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/afba7431b1194dcfab433254d9632338.png
[68e21c1f7c8e4c20883998a763f8a622.png]: /images/20220829/c463a53770de4921be4f1d1d40c897e9.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220829/6de198c6d08c427aba522bd586b6e242.png
[cd50fbb2f20c4bdca726617d9956d8a1.png]: /images/20220829/f12cbe5713ce416cbde2e36f5da0b3d7.png
[68158f3db61f44daab1c9fe65bf6cb70.png]: /images/20220829/352b0b55f00241a6ab5327399d6da253.png
[a0ee3d30d4c14455a75a7e0fe4858a04.png]: /images/20220829/1f51975768b947159e664a5d30ad1a04.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220829/a1734f1f839a4a818a4a559a3408364a.png
[ab573b1541d8454e824e281e2a0d51cd.png]: /images/20220829/0d2197db969a4b589f7f64d53b720ad3.png
[540b932d2bc64496812e7bd455b03251.png]: /images/20220829/c101b4c3335e43b89a9662dc0b27c6ba.png
[e38964ba885245d6b7186e83be777fb6.png]: /images/20220829/e7cbc954737c45aebca3f857cd250d3d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220829/f8566115327f48409ad8ca9476659a67.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220829/37ec244b14874ed68e455785e3f389de.png
[af68bf2961584c599b571c52c080f89d.png]: /images/20220829/ee7ce6c634284de29f174d46bb7b44f2.png
[9ff381f8797f47b8832099ae8b944f20.png]: /images/20220829/cd806a3cd3c24fa8ae9e985fcce8bea0.png
[9b23376bd2c44e4fb7773bf280728d78.png]: /images/20220829/e22a546fcd01403190c9f19469be5e5d.png
[34169f97638b485393ecd9d56a028e95.png]: /images/20220829/49855b35df7b4c3785938adeaa40fdb2.png
[2c350f7735e34f49b269bdd164e923e8.png]: /images/20220829/a5629b50171746c98627b7816e1264c7.png