前言
由于C++是静态语言,也就是说使用一个数据的时候必须先指定类型,这样的操作在编译后变量的类型是无法轻易改变的,就导致扩展性太差。或者一个函数需要很多次重载的时候，代码显得冗杂，由此产生了C++函数模板。
一、函数模板
1.函数模板介绍
① 函数模板的产生背景:
在编程时多多少少会因为函数参数不同写几个重载函数； 函数模板的出现解决了仅仅因为参数类型不同而进行的函数重载; 解决方法:让类型作为参数传进函数或者自动类型推导,从而实现不同的功能;
② 函数模板的语法：
template<typename T> 返回类型 函数名(参数列表){函数体} • 1 • 2
③ 函数模板的调用方式:
1.明显的调用 函数名<参数类型>（实参）;-------------常用 2.自动函数推导 函数名（实参）
④ 函数模板的本质:类型参数化！
函数模板举例
重载了三次的max函数,使用函数模板一次就可以解决
#include<iostream> using namespace std; //--------------------------------函数模板前的比较大小 int max(int a,char b) { return (a > b ? a : b); } float max(float a, float b) { return (a > b ? a : b); } long int max(long int a, long int b) { return (a > b ? a : b); } //--------------------------------用函数模板进行比较大小 template<typename T> T max(T& a, T& b) { return (a > b ? a : b); } int main_001() { int a = 10; int b = 20; char a2 = 'a',b2='b'; cout << max<int >(a, b) << endl; cout<<max(a, b)<<endl; cout << max(a2, b2) << endl;; return 0; }
2.函数模板与重载函数的关系
① 普通函数的特性:
可以(隐式)进行参数类型自动转换； • 1
② 函数模板的特性:
函数参数类型相同的话传进来的实参类型也必须相同(不允许自动转换);
调用规则:
- 调用函数时优先考虑普通函数
- 如果函数模板会有一个更好的匹配,那么选择模板函数；
- 可以通过空模板实参列表的语法限定编译器只通过模板匹配；
- 函数模板像普通函数一样也可以被重载
- 使用规则如下：
#include<iostream> using namespace std; //此函数模板T1 T2代表两个不同类型的参数 //所以传进来的参数也要是不同类型（可以通过简单的操作改为传相同类型的参数） template<typename T1,typename T2> int myadd(T1 a, T2 b) { return a + b; } int myadd(int a, int b) { return a + b; } int myadd(int a, char b) { return a + b; } int main() { int a = 10; int b = 20; char c = 'c'; cout << myadd(a,b) << endl;//----------调用add(int,int)-----优先匹配的普通函数 cout << myadd(a,c) << endl;//----------调用add(int ,char) cout << myadd(c,a) << endl;//----------调用add(t1,t2)-------没有该类型的普通函数就调用模板函数 cout << myadd(c,c) << endl;//----------调用add(t1,t2) cout << myadd<>(a, b) << endl;//-------强制调用add(t1,t2) return 0; }
3.函数模板实现机制
① 函数模板与模板函数：
1.函数模板:------------------------------仅仅是一个模板,并未被实例化(空壳子) template <typename T> 返回类型 函数名 (参数列表){函数体} 2.模板函数:------------------------------通过类型的传入,将函数模板实例化 函数模板的函数名<类型名>(参数列表);
② 函数模板机制剖析：
函数模板并不会直接产生能处理任意类型的参数的函数; 而是通过产生对应的模板函数实现对不同类型参数的处理； 函数模板进行两次编译 1.函数模板声明的地方,对函数模板代码本身进行编译 2.将类型插入后在调用的地方对插入参数后的代码进行编译
二、类模板
1.类模板基本语法
① 单个模板类:
基本语法: template<typename T>或template<class T> class 类名{private: T a;}; 注意事项: 模板类是一个抽象类,定义对象时需要参数类型的传入 具体实现如下:
#include<iostream> using namespace std; template <class T> class A { public: void seta(T &a) { this->a = a; } void printA() { cout << this->a << endl; } protected: T a; }; int main() { int x = 888; A<int> a1; a1.seta(x); a1.printA(); char xx = 'x'; A<char> a2; a2.seta(xx); a2.printA(); return 0; }
② 模板类被具体类继承:
基本语法: 定义: class 具体类名 :public 模板类名<参数类型>{}; 继承后的操作与普通类之间继承一样; 实现方法如下:
#include<iostream> using namespace std; template <class T> class A { public: void seta(T &a) { this->a = a; } void printA() { cout << this->a << endl; } protected: T a; }; class B :public A<int> { private: int b; public: void setb(int b) { this->b = b; } void printB() { cout << this->b << endl; } }; int main() { int x = 888; B b1; b1.setb(999); b1.printB(); b1.seta(x); b1.printA(); return 0; }
③ 模板类被模板类继承
类继承: 基本语法: template<typename T> class 模板类名 :public 基类模板类名<T>{ }; 具体实现方法:
#include<iostream> using namespace std; template <class T> class A { public: void seta(T &a) { this->a = a; } void printA() { cout << this->a << endl; } protected: T a; }; template <class T> class C :public A<T> {//----------语法所在地 private: T c; public: void setC(T &c) { this->c = c; } void printC() { cout << this->c << endl; } }; class B :public A<int> { private: int b; public: void setb(int b) { this->b = b; } void printB() { cout << this->b << endl; } }; int main() { int p = 99; C<int> c1; c1.setC(p); c1.printC(); char pp = '6'; C<char> c2; c2.setC(pp); c2.printC(); return 0; }
2.类模板内函数的整体布局【分文件使用类模板】
①所有函数均在类的内部
实现方法如下:
#include<iostream> using namespace std; template<typename T> class complex1 { friend ostream& operator<< <T>(ostream &out, complex1 &obj); private: T a; T b; public: complex1(T a=0, T b=0) { this->a = a; this->b = b; } complex1 operator+(complex1 obj) { complex1 tem(a+obj.a,b+obj.b); return tem; } void printa() { cout << a << endl; } void printb() { cout << b << endl; } }; template<typename T> ostream& operator<<(ostream &out, complex1<T> &obj) { out << obj.a << "+" << obj.b << "i" << endl; return out; } int main_11() { complex1<int> a(1, 2), b(3, 4); complex1<int>c = a + b; cout << c << a << b; a.printa(); a.printb(); return 0; }
②所有函数均在类的外部,但在同一文件
成员函数实现语法: 原型: 类名 函数名 （参数列表）; 修改后的形式: template <typename T> 类名<T> 函数名 （参数列表）------参数列表该加T的就加T 流运算符 友元函数实现语法: 原型(声明): friend 返回类型 函数名 （参数列表）； 修改后的形式: (声明) ：friend 返回类型 函数名 <T> (参数列表) ； template<typename T> (函数实现): 返回类型 函数名 （参数列表）{};------类的对象做参数时修改为 类名<T>;
具体实现如下
#include<iostream> using namespace std; template<typename T> class complex2 { friend ostream& operator<< <T>(ostream& out, complex2& obj); private: T a; T b; public: complex2(T a = 0, T b = 0); complex2 operator+(complex2 obj); void printa(); void printb(); }; template<typename T> complex2<T>::complex2<T>(T a , T b ) { this->a = a; this->b = b; } template<typename T> complex2<T> complex2<T>::operator+(complex2 obj) { complex2 tem(a + obj.a, b + obj.b); return tem; } template<typename T> void complex2<T>::printa() { cout << a << endl; } template<typename T> void complex2<T>::printb() { cout << b << endl; } template<typename T> ostream& operator<<(ostream& out, complex2<T>& obj) { out << obj.a << "+" << obj.b << "i" << endl; return out; } int main_dd() { complex2<int> a(1, 2), b(3, 4); complex2<int>c = a + b; cout << c << a << b; a.printa(); a.printb(); return 0; }
③ 所有函数均在类的外部,但在不同文件
将类分文件写后,将类函数实现的部分包含进主函数所在的文件 实现方法: #include"xxxx.cpp" 示例:
头文件
#pragma once #include<iostream> using namespace std; template<typename T> class complex { friend ostream& operator<< <T>(ostream& out, complex& obj); private: T a; T b; public: complex(T a = 0, T b = 0); complex operator+(complex obj); void printa(); void printb(); };
函数实现
#include<iostream> using namespace std; #include"复数类3.h" template<typename T> complex<T>::complex<T>(T a, T b) { this->a = a; this->b = b; } template<typename T> complex<T> complex<T>::operator+(complex obj) { complex tem(a + obj.a, b + obj.b); return tem; } template<typename T> void complex<T>::printa() { cout << a << endl; } template<typename T> void complex<T>::printb() { cout << b << endl; } template<typename T> ostream& operator<<(ostream& out, complex<T>& obj) { out << obj.a << "+" << obj.b << "i" << endl; return out; }
主函数
#include<iostream> using namespace std; #include"复数类3h.cpp"//重点 int main() { complex<int> a(1, 2), b(3, 4); complex<int>c = a + b; cout << c << a << b; a.printa(); a.printb(); return 0; }
3.类模板的static与模板类的static
类模板定义了变量,函数实现的步骤,但没有数据类型的插入,所以类模板仅仅是模板; 类模板的实现机制是程序员给出数据类型,编译器对具体的类进行实现,产生不同类型的类; 所以,类模板中的静态成员变量是某个类型的具体类独有的成员变量;只是被该类型对象所公有 区别如下： 模板类中的static变量可以被该模板类的对象公用 类模板的static经过类不同方式的实例化,会产生不同的static变量， 且该变量只供初始化他的类使用
4.数组实现万能容器
testarray类是一个类模板，里面有一个指针类型,所以通过程序员主动实现模板类传参 可以存储不同类型的数据,也就是说testarray理论可以存储任意类型的数据。
#include<iostream> using namespace std; class teacher { private: char *name; char *sex; int age; public: teacher() { name = NULL; sex = NULL; age = 0; } teacher(teacher& obj) { if (name != NULL) { delete [] name; delete[] sex; } age = obj.age; name = new char [sizeof(obj.name)]; sex = new char[sizeof(obj.sex)]; strcpy_s(name, sizeof(obj.name), obj.name); strcpy_s(sex, sizeof(obj.sex), sex); } void setname(char *name) { this->name = new char[strlen(name)+1]; strcpy_s(this->name, strlen(name)+1, name); } void setage(int age) { this->age = age; } void setsex(char* sex) { this->sex = new char[strlen(sex)+1]; strcpy_s(this->sex, strlen(sex)+1, sex); } friend ostream& operator<<(ostream& out, teacher& obj); }; ostream& operator<<(ostream& out, teacher& obj) { cout << "姓名" << "\t" << "性别" << "\t" << "年龄" << endl; cout << obj.name << "\t" << obj.sex << "\t" << obj.age << endl; return out; } ostream& operator<<(ostream& out, teacher& obj); template <typename T> class testarray { friend ostream& operator<< <T>(ostream& out, testarray& obj); private: int len; T* myarray; public: testarray() { len = 0; myarray = NULL; } testarray(int len) { this->len=len; myarray = new T[len]; } testarray(testarray & obj) { len = obj.len; myarray = new testarray; strcmp_s(myarray, len, obj.myarray); } T& operator[](int xx) { return myarray[xx]; } }; template<typename T> ostream& operator<<(ostream& out,testarray<T>& obj) { for (int i = 0;i < obj.len;i++) { cout << obj[i] <<" "; } cout << endl; return out; } int main() { testarray<int> aint(10); testarray<char> bchar(10); testarray<teacher> tea(3); teacher t1, t2, t3; char name1[]="小李",name2[]="小朱",name3[]="小黄"; char sex1[] = "男", sex2[] = "女"; t1.setname(name1); t1.setsex(sex2); t1.setage(40); t2.setname(name2); t2.setsex(sex1); t2.setage(20); t3.setname(name3); t3.setsex(sex1); t3.setage(28); tea[0] = t1; tea[1] = t2; tea[2] = t3; for (int i = 0;i < 10;i++) { aint[i] = i; } for (int i = 0;i < 10;i++) { bchar[i] = i + 97; } cout << aint; cout << bchar; cout << tea; return 0; }
效果图
实现思路 类模板实现对不同数据类型的变量进行处理后 该变量要有针对该操作 自己处理自身的方法 换句话说就是 类模板仅仅对某种类型的处理发出指令 而细枝末节的处理方式(算法),要该类型自己的方法去实现
总结
类模板与函数模板一样也会经过两次编译,在此文中重点区分一下类模板与模板类,函数模板与模板函数的概念,泛型编程是C++开发的一大精髓,灵活地运用泛型编程对我们以后学习其他的编程语言有很大的帮助,后期还会更新一些C++小demo,包括C++三大特性的运用与泛型机制的运用，还会更新C++图像库easyX。欢迎大家点赞收藏。
