C++模板
模板
函数模板
c++提供了函数模板(function template.)
所谓函数模板,实际上是建立一个通用函数,其函数类型和形参类型不具体制定,用一个虚拟的类型来代表。这个通用函数就成为函数模板。
凡是函数体相同的函数都可以用这个模板代替,不必定义多个函数,只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型,从而实现不同函数的功能。
- c++提供两种模板机制:函数模板和类模板
- 类属 - 类型参数化,又称参数模板
总结:
- 模板把函数或类要处理的数据类型参数化,表现为参数的多态性,成为类属。
- 模板用于表达逻辑结构相同,但具体数据元素类型不同的数据对象的通用行为。
void mySwapInt(int &a ,int &b)
{
int temp = a;
a = b;
b = temp;
}
void mySwapDouble(double &a, double &b)
{
double temp = a;
a = b;
b = temp;
}
//利用模板实现通用交换函数
template<typename T> //T代表一个通用的数据类型,告诉编译器如果下面紧跟着的函数或者类中出现T不要报错
void mySwap(T &a, T &b)
{
T temp = a;
a = b;
b = temp;
}
//模板不能单独使用,必须指定出T才可以使用
template<typename T>
void mySwap2()
{
}
void test01()
{
int a = 10;
int b = 20;
// mySwapInt(a, b);
char c1 = 'c';
//1、自动类型推导,必须推导出一致的T数据类型,才可以正常的使用模板,如果使用自动类型推导不能发生隐式类型转换
//mySwap(a, c1); //推导不出一致的T,因此无法调用
//mySwap(a, b);
//2、显示指定类型
mySwap<int>(a, b);
mySwap2<int>(); //必须告诉编译器T类型才可以调用
cout << a << endl;
cout << b << endl;
double c = 3.14;
double d = 1.1;
// mySwapDouble(c, d);
mySwap(c, d);
cout << c << endl;
cout << d << endl;
}
- 泛型编程 – 模板技术 特点:类型参数化
template< typename T >
告诉编译器后面紧跟着的函数或者类中出现T
,不要报错,T
是一个通用的数据类型- 实现通用两个数进行交换函数
- 使用
- 自动类型推导 必须要推导出一致的T才可以使用
- 显示指定类型
mySwap<int>(a,b);
函数模板和普通函数区别
- 函数模板不允许自动类型转化
- 普通函数能够自动进行类型转化
函数模板和普通函数的区别以及调用规则
区别
- 如果使用自动类型推导,是不可以发生隐式类型转换的
- 普通函数 可以发生隐式类型转换
调用规则
- 如果函数模板和普通函数都可以调用,那么优先调用普通函数
template<class T>
void myPrint(T a, T b)
{
cout << "函数模板调用" << endl;
}
template<class T>
void myPrint(T a, T b, T c)
{
cout << "函数模板(T a, T b ,T c)调用" << endl;
}
void myPrint(int a, int b)
{
cout << "普通函数调用" << endl;
}
void test()
{
//1、如果函数模板和普通函数都可以调用,那么优先调用普通函数
int a = 10;
int b = 20;
myPrint(a, b);
}
- 如果想强制调用函数模板,可以使用空模板参数列表
myPrint<>(a, b);
template<class T>
void myPrint(T a, T b)
{
cout << "函数模板调用" << endl;
}
template<class T>void myPrint(T a, T b, T c)
{
cout << "函数模板(T a, T b ,T c)调用" << endl;
}
void myPrint(int a, int b)
{
cout << "普通函数调用" << endl;
}
void test02()
{
//1、如果函数模板和普通函数都可以调用,那么优先调用普通函数
int a = 10;
int b = 20;
//2、如果想强制调用函数模板,可以使用空模板参数列表
myPrint<>(a, b);
}
- 函数模板也可以发生函数重载
- 如果函数模板能产生更好的匹配,那么优先使用函数模板
//4、如果函数模板能产生更好的匹配,那么优先使用函数模板
char c = 'c';
char d = 'd';
myPrint(c, d);
模板的实现机制
- 编译器并不是把函数模板处理成能够处理任何类型的函数
- 函数模板通过具体类型产生不同的函数,通过函数模板产生的函数 称为模板函数
void myPrint(int a ,int b)
{
cout << "函数模板调用" << endl;
}
void myPrint(double a ,double b)
{
cout << "函数模板调用" << endl;
}
- 编译器会对函数模板进行两次编译,在声明的地方对模板代码本身进行编译,在调用的地方对参数替换后的代码进行编译。
模板局限性
- 模板并不是真实的通用,对于自定义数据类型,可以使用具体化技术,实现对自定义数据类型特殊使用
template<> bool myCompare(Person &a, Person &b)
#include <string>
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
//显示两个变量 对比 函数
template<class T>
bool myCompare(T &a ,T&b)
{
if (a == b)
{
return true;
}
return false;
}
//利用具体化技术 实现对自定义数据类型 提供特殊模板
template<> bool myCompare(Person &a, Person &b)
{
if (a.m_Name == b.m_Name && a.m_Age == b.m_Age)
{
return true;
}
return false;
}
void test()
{
Person p1("Tom", 19);
Person p2("Tom", 20);
bool ret = myCompare(p1, p2);
if (ret)
{
cout << "p1 == p2" << endl;
}
else
{
cout << "p1 != p2" << endl;
}
}
当myCompare
模板该当,不满足自定义的数据类型时可以通过以下两种方式进行完善
- 重载方法中用到的运算符
=
- 利用具体化技术 实现对自定义数据类型 提供特殊模板
template<> bool myCompare(Person &a, Person &b)
{
if (a.m_Name == b.m_Name && a.m_Age == b.m_Age)
{
return true;
}
return false;
}
类模板
类模板和函数模板区别:
- 类模板不可以使用自动类型推导,只能用显示指定类型
Person<string,int> p1("孙悟空", 100);
- 类模板中 可以有默认参数
template<class NAMETYPE, class AGETYPE = int >
#include <string>
template<class NAMETYPE, class AGETYPE = int > //类模板中 可以有默认参数
class Person
{
public:
Person(NAMETYPE name, AGETYPE age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "姓名: " << this->m_Name << " 年龄: " << this->m_Age << endl;
}
NAMETYPE m_Name;
AGETYPE m_Age;
};
void test01()
{
//类模板和函数模板区别:
//1、类模板不可以使用自动类型推导,只能用显示指定类型
//2、类模板中 可以有默认参数
//Person p1("孙悟空", 100);
Person<string > p1("孙悟空", 100);
p1.showPerson();
}
类模板中成员函数创建时机
类模板中的成员函数 ,并不是一开始创建的,而是在运行阶段确定出T
的数据类型才去创建
class Person1
{
public:
void showPerson1()
{
cout << "Person1 show 调用" << endl;
}
};
class Person2
{
public:
void showPerson2()
{
cout << "Person2 show 调用" << endl;
}
};
//类模板中的成员函数 ,并不是一开始创建的,而是在运行阶段确定出T的数据类型才去创建
template<class T>
class MyClass
{
public:
void func1()
{
obj.showPerson1();
}
void func2()
{
obj.showPerson2();
}
T obj;
};
//代码可以生成,但是调用的时候会报错,只能调用指定T类型的方法
void test01()
{
MyClass <Person2> p1;
//p1.func1();
p1.func2();
}
类模板做函数参数
using namespace std;
#include <string>
template<class T1, class T2> //类模板中 可以有默认参数
class Person
{
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "姓名: " << this->m_Name << " 年龄: " << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//1、指定传入类型
void doWork(Person <string, int>&p)
{
p.showPerson();
}
void test01()
{
Person <string, int>p("孙悟空", 999);
doWork(p);
}
//2、参数模板化(模板方法)
template<class T1, class T2>
void doWork2(Person <T1, T2>&p)
{
cout << "T1数据类型: " << typeid(T1).name() << endl;
cout << "T2数据类型: " << typeid(T2).name() << endl;
p.showPerson();
}
void test02()
{
Person<string, int>p("猪八戒", 998);
doWork2(p);
}
//3、整个类模板化
template<class T>
void doWork3( T &p)
{
cout << "T的数据类型: " << typeid(T).name() << endl;
p.showPerson();
}
void test03()
{
Person<string, int>p("唐僧", 10000);
doWork3(p);
}
使用方式有三种
- 一、指定传入类型(推荐使用)
void doWork(Person <string, int>&p)
- 二、参数模板化
template<class T1, class T2>
void doWork2(Person <T1, T2>&p)
- 三、整个类模板化
template<class T>
void doWork3( T &p)
查看T数据类型
typeid(T).name()
类模板碰到继承的问题以及解决
- 必须要指定出父类中的
T
数据类型,才能给子类分配内存
template<class T>
class Base
{
public:
T m_A;
};
//必须要指定出父类中的T数据类型,才能给子类分配内存
class Son :public Base<int>
{
};
- 子类也声明为模板方法
template<class T>
class Base2
{
public:
T m_A;
};
//1.子类也声明为模板方法
template<class T1 ,class T2>
class Son2 :public Base2<T2>
{
public:
Son2()
{
cout << typeid(T1).name() << endl;
cout << typeid(T2).name() << endl;
}
T1 m_B;
};
void test()
{
//调用时指定实际类型
Son2 <int, double> s;
}
类模板中的成员函数类外实现
#include <string>
template<class T1,class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPerson();
T1 m_Name;
T2 m_Age;
};
//类外实现,再次声明T1,T2
template<class T1,class T2>
Person<T1,T2>::Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
// 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}
void test()
{
Person <string, int> p("Tom", 10);
p.showPerson();
}
类模板的分文件编写问题以及解决
原因:类模板中的成员函数,不会一开始创建,因此导致分文件编写时连接不到函数的实现,出现无法解析的外部命令错误。
- 解决方式1:直接包含
.cpp
文件 (不推荐) - 解决方式2:将类声明和实现写到同一个文件中,将文件的后缀名改为
.hpp
即可
person.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPerson();
T1 m_Name;
T2 m_Age;
};
person.cpp
#include "person.h"
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}
person.hpp,声明为.hpp
文件,包含头文件及实现
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPerson();
T1 m_Name;
T2 m_Age;
};
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}
类模板碰到友元的问题以及解决
- 友元类内实现
template<class T1, class T2>
class Person
{
//1、友元函数 类内实现
friend void printPerson(Person<T1, T2> &p)
{
cout << "姓名: " << p.m_Name << " 年龄: " << p.m_Age << endl;
}
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
void test()
{
Person <string, int> p("Tom", 100);
printPerson(p);
}
- 友元类外实现
//1.声明模板类
template<class T1,class T2>
class Person;
//2.声明模板方法(要在声明模板类Person之后)
template<class T1,class T2>
void printPerson(Person<T1, T2> &p);
template<class T1, class T2>
class Person
{
//2、友元函数 类外实现,模板方法printPerson<>
friend void printPerson<>(Person<T1, T2> &p);
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
//友元模板函数类外实现
template<class T1,class T2>
void printPerson(Person<T1, T2> &p)
{
cout << "类外实现 --- 姓名: " << p.m_Name << " 年龄: " << p.m_Age << endl;
}
void test()
{
Person <string, int> p("Tom", 100);
printPerson(p);
}
- 声明及实现放在一起
template<class T1,class T2>
class Person;
//声明时直接实现
template<class T1,class T2>
void printPerson(Person<T1, T2>&p)
{
cout << "类外实现 --- 姓名: " << p.m_Name << " 年龄: " << p.m_Age << endl;
}
template<class T1, class T2>
class Person
{
friend void printPerson<>(Person<T1, T2> &p);
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
void test01()
{
Person <string, int> p("Tom", 100);
printPerson(p);
}
类模板应用 – 数组类封装
myArray.hpp
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
template<class T>
class MyArray
{
public:
//MyArray(){};
//有参构造
MyArray(int capacity)
{
this->m_Capacity = capacity;
this->m_Size = 0;
this->pAddress = new T[this->m_Capacity];
}
//拷贝构造
MyArray(const MyArray & arr)
{
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < arr.m_Size;i++)
{
this->pAddress[i] = arr.pAddress[i];
}
}
//重载=
MyArray& operator=( const MyArray & arr)
{
if (this->pAddress)
{
delete[] this->pAddress;
this->pAddress = NULL;
}
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
this->pAddress = new T[this->m_Capacity];
for (int i = 0; i < arr.m_Size; i++)
{
this->pAddress[i] = arr.pAddress[i];
}
return *this;
}
//重载[]
T& operator[] (int index)
{
return this->pAddress[index];
}
//尾插法
void pushBack(const T&val)
{
if (this->m_Capacity == this->m_Size)
{
return;
}
this->pAddress[this->m_Size] = val;
this->m_Size++;
}
//获取数组容量
int getCapacity()
{
return this->m_Capacity;
}
//获取数组大小
int getSize()
{
return this->m_Size;
}
//析构
~MyArray()
{
if (this->pAddress)
{
//数组的释放
delete[] this->pAddress;
this->pAddress = NULL;
}
}
private:
T * pAddress; //指向堆区真实数组指针
int m_Capacity; //数组容量
int m_Size; //数组大小
};