C++由浅入深(五)
本阶段主要针对C++泛型编程和STL技术做详细讲解,探讨C++更深层的使用
1 模板
模板的概念
模板就是建立通用的模具,大大提高复用性
特点:模板不可以直接使用,它只是一个框架。模板的通用并不是万能的。
函数模板
- C++另一种编程思想称为泛型编程,主要利用的技术就是模板
- C++提供两种模板机制:函数模板和类模板。
模板语法
函数模板作用:
建立一个通用函数,其函数返回值类型和形参类型可以不具体制定,用一个虚拟的类型来代表。
语法:
template<typename T>
函数声明或定义
解释:
template——声明创建模板
typename——表面其后面的符号是一种数据类型,可以用class代替
T——通用的数据类型,名称可以替换,通常为大写字母
template<typename T>//T为通用数据类型
void mySwap(T &a, T &b) {
T temp = a;
a = b;
b = temp;
}
void test01() {
int a = 10;
int b = 20;
//1.自动类型推导
mySwap(a, b);
//2.显示指定类型
mySwap<int>(a, b);
}
注意事项
- 自动类型推导,必须推导出一致的数据类型T,才可以使用
- 模板必须要确定出T的数据类型,才可以使用
template<typename T>//T为通用数据类型
void func() {
cout<<"asdas"<<endl;
}
void test02() {
func<int>(); //要指定出func的数据类型才能使用
}
普通函数与函数模板的区别
- 普通函数调用时可以发生自动类型转换(隐式类型转换)
- 函数模板调用时,如果利用自动类型推导,不会发生隐式类型转换
- 如果利用显示指定类型的方式,可以发生隐式类型转换
int myadd(int a,int b) {
return a + b;
}
template<class T>
T myadd002(T a, T b) {
return a + b;
}
void test01() {
int a = 10;
int b = 20;
char c = 'c';
cout << myadd(a, c) << endl;
//自动类型推导
//cout<<myadd002(a,c)<<endl; //不会进行转换
myadd002<int>(a, c);//可以进行转换,因为可以进行转换
}
普通函数与函数模板的调用规则
调用规则如下:
1.如果函数模板和普通函数都可以实现,优先调用普通函数
2.可以通过空模板参数列表来强制调用函数模板
3.函数模板也可以发生重载
4.如果函数模板可以产生更好的匹配,优先调用函数模板
void myPrint(int a, int b)
{
cout<<"调用的普通函数"<<endl;
}
template<class T>
void myPrint(T a, T b) {
cout << "调用的模板" << endl;
}
template<class T>
void myPrint(T a, T b,T c) {
cout << "调用的重载模板" << endl;
}
void test01() {
int a = 10;
int b = 20;
myPrint(a, b); //先调用普通函数,只有声明也是调用函数
myPrint<>(a, b);//通过空模板强制调用函数模板
myPrint<>(a, b, 100);//调用重载模板
//编译器会首先调用模板
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2);
}
总结:提供了函数模板就不要出现函数,会出现二义性,利用具体化的模板,可以解决自定义类型的通用化。
类模板
作用:建立一个通用类,类中的成员、数据类型可以不具体制定,用一个虚拟的类型来代表。
语法:
template<typename T> //声明创建模板
类
template <class NameType,class AgeType>//用两个类模板
//template <class NameType,class AgeType = int>可以规定模板的参数,下面实例化时候就可以不用写类型
class Person {
public:
Person(NameType name,AgeType age){
m_age = age;
m_name = name;
}
void show() {
cout << this->m_age << this->m_name << endl;
}
private:
int m_age;
string m_name;
};
void test01()
{
Person<string, int> p1("孙悟空", 99);//要显示制定的数据类型
//Person<string> p1("猪八戒", 99);写了规定参数就可以不用规定类型
p1.show();
}
类模板与函数模板的区别
1.类模板没有自动类型推导的使用方式
2.类模板在模板参数列表中可以有默认参数
类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数创建时机是有区别的:
- 普通类中的成员函数一开始就可以创建
- 类模板中的成员函数在调用时才创建
class Person1 {
public:
void showPerson1() {
cout<<"Person1 show"<<endl;
}
};
class Person2 {
public:
void showPerson2() {
cout << "Person2 show" << endl;
}
};
template<class T>
class Myclass {
public:
T obj;
//类模板中的成员函数
void func1() {
obj.showPerson1(); //只要没调用,就不会创建
}
void func2() {
obj.showPerson2();
}
};
void test01() {
Myclass<Person1>m;
m.func1();
//m.func2();
}
类模板对象做函数参数
- 类模板实例化出的对象,向函数传参的方式
一共有三种传入方式:
1.指定传入的类型——直接显示对象的数据类型
2.参数模板化——将对象中的参数变为模板进行传递
3.整个类模板化——将这个对象类型 模板化进行传递
template<class T1,class T2>
class Person {
public:
Person(T1 name, T2 age) {
this->m_Age = age;
this->m_Name = name;
}
void showPerson() {
cout<<this->m_Age<<this->m_Name<<endl;
}
T1 m_Name;
T2 m_Age;
};
//传入指定类型(常用)
void printPerson1(Person<string, int>&p) {
p.showPerson();
}
//参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2>&p){
p.showPerson();
cout << "T1的类型" << typeid(T1).name() << endl;//typeid用来查看类型
}
//整个类模板化
template<class T>
void printPerson3(T &p) {
p.showPerson();
}
void test03() {
Person<string, int>p("唐僧", 30);
printPerson3(p);
}
void test02() {
Person<string, int>p("猪八戒", 90);
printPerson2(p);
}
void test01() {
Person<string, int>p("孙悟空", 100);
printPerson1(p);
}
类模板与继承
template<class T>
class Base {
T m;
};
//template<class T>
class Son :public Base<int>//继承要说明T的数据类型
{
};
void test01() {
Son s1;
}
//如果想灵活指定父类中的T类型,子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2> { //T2是继承Base的T
T1 obj;
};
void test02() {
Son2<int, char>S2;
}
类模板成员函数类外实现
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;
};
//构造函数的类外实现
template<class T1,class T2>
Person<T1,T2>::Person(T1 name, T2 age) {//Person里面要加T1,T2参数
{
this->m_Name = name;
this->m_Age = age;
}
}
template<class T1, class T2>
void Person<T1,T2>::showPerson() {
}
类模板分文件编写
掌握类模板成员函数分文件编写产生的问题以及解决方式
问题:
- 类模板中成员函数创建时机是在调用阶段,导致分文件编写链接不到。
解决:
- 解决方式1:直接包含.cpp源文件
- 解决方式2:将声明和实现写到同一个文件中,并更改后缀名为.hpp,hpp是约定的名称,并不是强制
//#include"Person.h"因为系统不会创建模板,所以要包含.cpp的文件
//第一钟解决方式,直接包含源文件
#include"Person.cpp"
//第二种解决方式,将.h和.cpp的内容写到一起,将后缀名改为.hpp文件,hpp文件就是类模板文件
#include "Person.hpp"
using namespace std;
void test01() {
Person<string, int>p("Jerry", 18);
p.showPerson();
}
Person.hpp:
#pragma once
#include<iostream>
#include<string>
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;
}
类模板与友元
- 全局函数类内实现:直接在类内声明友元即可
- 全局函数类外实现:需要提前让编译器知道全局函数的存在。
//类外实现要先声明Person类的存在
template<class T1,class T2>
class Person;
//通过全局函数 打印Person信息
//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p) { //不用加作用域,因为这是全局函数
cout << "类外实现" << p.m_name << endl;
}
template<class T1,class T2>
class Person {
//全局函数 类内实现
friend void printPerson(Person<T1,T2> p) { //全局函数类内实现
cout << p.m_name << endl;
}
//全局函数 类外实现
//如果全局函数是类外实现,需要让编译器提前知道这个函数的存在
friend void printPerson2<>(Person<T1, T2> p);//这只是普通函数的声明,要告诉链接器这是模板printPerson2加括号
public:
Person(T1 name, T2 age) {
this->m_name = name;
this->m_age = age;
}
private:
T1 m_name;
T2 m_age;
};
//1.全局函数在类内实现
void test01() {
Person<string, int>p("Tom", 20);
printPerson(p);
}
void test02() {
Person<string, int>p("Jerry", 20);
printPerson2(p);
}
int main() {
//test01();
test02();
return 0;
}