19、类模板

最新推荐文章于 2021-01-31 13:59:07 发布

Stay hungry. Stay foolish.

最新推荐文章于 2021-01-31 13:59:07 发布

阅读量330

点赞数

分类专栏： c++

本文链接：https://blog.csdn.net/wuzhishiwo/article/details/108095266

版权

c++ 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

此文编写参考狄泰软件学院唐佐林老师的视频课程，如有错误之处，欢迎指正。

一、什么是类模板

1、为什么需要类模板？

一些类主要用于存储和组织数据元素
类中数据组织的方式和数据元素的具体类型无关
如：数组类，链表类，Stack类，Queue类，等。

意义：c++中将模板的思想应用于类，使得类的实现不关注数据元素的具体类型，而只需要关注类所需要实现的功能。

2、c++中的类模板

以相同的方式处理不同的类型
在类声明前使用template进行标识
<typename T>用于说明类中使用的泛指类型T

（1）语法

template <typename T>
class Operator
{
public:
	T op(T a,T b);
}

（2）类模板的应用

只能显示指定具体类型，无法自动推导
使用具体类型<Type>定义对象

Operator<int> op1;
Operator<string> op2;
int i=op1.op(1,2);
string s=op2.op("wo","hao");

例程1：

#include<iostream>
#include<string>

using namespace std;

template <typename T>
class Operator
{
public:
	T Add(T a,T b)
	{
		return a+b;
	}
	T Minus(T a,T b)
	{
		return a-b;
	}
	T Multiply(T a,T b)
	{
		return a*b;
	}
	T Devide(T a,T b)
	{
		return a/b;
	}
};
string operator -(string& l,string& r)
{
	return "Minus";
}
int main()
{
	Operator<int> op1;
	cout<<"op1.Add(1,2)="<<op1.Add(1,2)<<endl;
	
	Operator<string> op2;
	cout<<"op2.Add(wo,hao)="<<op2.Add("wo","hao")<<endl;
	cout<<"op2.Minus(wo,hao)="<<op2.Minus("wo","hao")<<endl;
	
	return 0;
}

在这里插入图片描述
分析：

声明的泛指类型T可以出现在类模板的任意地方
编译器对类模板的处理方式和函数模板相同
①从类模板通过具体类型产生具体的类
②在声明的地方对类模板代码本身进行编译
③在使用的地方对参数替换后的代码进行编译，也就是要编译两次
④虽然本身字符串不可以进行相减操作，但是此时编译器没有立即报错，而是查看下有没有对‘-’进行操作符重载。

二、类模板在工程实践中的几条建议

类模板必须在头文件中定义
类模板不能够分开实现在不同的文件中
类模板外部定义的成员函数需要加上模板<>声明

按照这3条建议，将上面的那个例程修改后得到的程序如下所示：
test.cpp//主函数

#include<iostream>
#include<string>
#include"Operator.h"
using namespace std;

int main()
{
	Operator<int> op1;
	cout<<"op1.Add(10,5)="<<op1.Add(10,5)<<endl;
	cout<<"op1.Minus(10,5)="<<op1.Minus(10,5)<<endl;
	cout<<"op1.Multiply(10,5)="<<op1.Multiply(10,5)<<endl;
	cout<<"op1.Devide(10,5)="<<op1.Devide(10,5)<<endl;
	return 0;
}

Operator.h

#ifndef _OPERATOR_H_
#define _OPERATOR_H_

template <typename T>
class Operator
{
public:
	T Add(T a,T b);
	T Minus(T a,T b);
	T Multiply(T a,T b);
	T Devide(T a,T b);
};

template <typename T>
T Operator<T>::Add(T a,T b)
{
	return a+b;
}

template <typename T>
T Operator<T>::Minus(T a,T b)
{
	return a-b;
}

template <typename T>
T Operator<T>::Multiply(T a,T b)
{
	return a*b;
}

template <typename T>
T Operator<T>::Devide(T a,T b)
{
	return a/b;
}
#endif

在这里插入图片描述

三、类模板的深度剖析

1、多参数类模板

（1）语法

template
<typename T1,typename T2>
class Test
{
public:
	void Add(T1 a,T2 b)
};
Test<int,float> t;

（2）类模板可以被特化

1、首先先了解特化的概念
特化分为全特化和部分特化
全特化：模板中的模板参数全部被指定为特定的类型，全特化也就是定义了一个全新的类型。完全产生确定的东西，不需要在编译期间搜寻合适的特化实现。
部分特化：模板中的模板参数没有被全部确定，需要在编译的时候进行确定

2、小结

指定类模板的特定实现
部分类型参数必须显示指定
根据类型参数分开实现类模板

3、例程：

#include <iostream>
#include <string>

using namespace std;

template
< typename T1, typename T2 >
class Test
{
public:
    void add(T1 a, T2 b)
    {
        cout << "void add(T1 a, T2 b)" << endl;
        cout << a + b << endl;
    }
};

template
< typename T1, typename T2 >//部分特化
class Test < T1*, T2* >      // 关于指针的特化实现
{
public:
    void add(T1* a, T2* b)
    {
        cout << "void add(T1* a, T2* b)" << endl;
        cout << *a + *b << endl;
    }
};

template
< typename T >//部分特化
class Test < T, T >    // 当 Test 类模板的两个类型参数完全相同时，使用这个实现
{
public:
    void add(T a, T b)
    {
        cout << "void add(T a, T b)" << endl;
        cout << a + b << endl;
    }
    void print()
    {
        cout << "class Test < T, T >" << endl;
    }
};

template//完全特化
<  >
class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
{
public:
    void add(void* a, void* b)
    {
        cout << "void add(void* a, void* b)" << endl;
        cout << "Error to add void* param..." << endl;
    }
};

int main()
{  
    Test<int, float> t1;
    Test<long, long> t2;
    Test<void*, void*> t3;
    
    t1.add(1, 2.5);
    
    t2.add(5, 5);
    t2.print();
    
    t3.add(NULL, NULL);
    
    Test<int*, double*> t4;
    int a = 1;
    double b = 0.1;
    
    t4.add(&a, &b);
    
    return 0;
}

在这里插入图片描述

2、类模板特化注意事项

特化只是模板的分开实现，本质上是同一个类模板
特化类模板的使用方式是统一的，必须显示指定每一个类型参数

3、类模板特化与重定义有区别吗？函数模板可以特化吗？

1、区别

重定义	①一个类模板和一个新类（或者两个类模板）； ② 使用时需要考虑如何选择的问题
特化	① 以统一的方式使用类模板和特化类； ②编译器自动优先选择特化类

如上例中如果不使用模板，而是重定义一个新类，那么就会很麻烦，使用时就需要考虑如何选择的问题，如下：

class Test_Void
{
public:
    void add(void* a, void* b)
    {
        cout << "void add(void* a, void* b)" << endl;
        cout << "Error to add void* param..." << endl;
    }
};

2、函数模板只支持类型参数完全特化
方法：

template 
<typename T>//函数模板定义
bool Equal(T a,T b)
{
	return a==b;
}

template 
<>//函数模板完全特化
bool Equal<void*>(void* a,void* b)
{
	return a==b;
}

例程：

#include <iostream>
#include <string>

using namespace std;

template
<typename T1,typename T2>
bool Equal(T1 a,T2 b)
{
	cout<<"bool Equal(T1 a,T2 b)"<<endl;
	return a==b;
}

template 
<>
bool Equal<double>(double a,double b)
{
	cout<<"bool Equal<double>(double a,double b)"<<endl;
	const double delta=0.0000001;
	double r=a-b;
	return (-delta<r)&&(r<delta);
}

bool Equal(double a,double b)
{
	cout<<"bool Equal(double a,double b)"<<endl;
	const double delta=0.0000001;
	double r=a-b;
	return (-delta<r)&&(r<delta);
}

int main()
{  
    cout<<"Equal(1,1)="<<Equal(1,1)<<endl;
    cout<<endl;
    cout<<"Equal(0.0001,0.0001)="<<Equal(0.0001,0.0001)<<endl;
    cout<<endl;
    cout<<"Equal<>(0.0001,0.0001)="<<Equal<>(0.0001,0.0001)<<endl;
    
    return 0;
}

在这里插入图片描述

4、工程建议和小结

工程建议	当需要重载函数模板时，优先考虑使用模板特化；当模板特化无法满足需求，再使用函数重载
小结	①类模板可以定义任意多个不同类型参数； ②类模板可以被部分或者完全特化； ③特化的本质是模板的分开实现； ④函数模板只支持完全特化；

Stay hungry. Stay foolish.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
19、类模板

此文编写参考狄泰软件学院唐佐林老师的视频课程，如有错误之处，欢迎指正。一、什么是类模板1、为什么需要类模板？一些类主要用于存储和组织数据元素类中数据组织的方式和数据元素的具体类型无关如：数组类，链表类，Stack类，Queue类，等。意义：c++中将模板的思想应用于类，使得类的实现不关注数据元素的具体类型，而只需要关注类所需要实现的功能。2、c++中的类模板以相同的方式处理不同的类型在类声明前使用template进行标识<typename T>用于说明类中使用的泛指
复制链接

扫一扫