针对C++泛型编程和STL技术做详细讲解,探讨C++更深层的使用。
1.模板
1.1模板的概念
模板就是建立通用的模具,大大提高复用性
日常生活例子帮助理解:一寸照片模板、PPT模板
1.2函数模板语法
函数模板作用:
建立一个通用函数,其函数返回值类型和形参类型可以不具体制定,用一个虚拟到类型来代表。
语法:
template<typename T>
函数声明或定义
解释:
template——声明创建模板
typename——表面其后面的符号是一种数据类型,可以用class代替
T——通用的数据类型,名称可以替换,通常为大写字母
示例:
#include<iostream>
using namespace std;
//函数模板
//交换两个整型的函数
void swapInt(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
//交换两个浮点型的函数
void swapDouble(double& a, double& b)
{
double temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 10;
int b = 20;
swapInt(a, b);
cout << "a=" << a << " " << "b=" << b << endl;
double c = 1.1;
double d = 2.2;
swapDouble(c, d);
cout << "c=" << c << " " << "d=" << d << endl;
}
//以上函数类型不同,但是逻辑相似
//所以可以用函数模板
template<typename T>//声明一个模板,告诉编译器后面代码中紧跟着的T不要报错,T是一个通用数据类型
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
void test02()
{
int a = 10;
int b = 20;
double c = 1.1;
double d = 2.2;
//利用函数模板交换
//利用两种方式使用
//1.自动类型推导
mySwap(a,b);
cout << "a=" << a << " " << "b=" << b << endl;
//2.显示指定类型
mySwap<double>(c, d);//提前声明模板的指定类型
cout << "c=" << c << " " << "d=" << d << endl;
}
int main()
{
test01();
test02();
return 0;
}
总结:
- 函数模版利用关键字template;
- 使用函数模板有两种方式:自动推导类型、显示指定类型
- 模板的目的是为了提高复用性,将类型参数化
1.2.2函数模板注意事项
注意事项:
- 自动类型推导,必须推导出一致数据类型T,才可以使用
- 模板必须要确定出T的数据类型,才可以使用
示例:
#include<iostream>
using namespace std;
//函数模板注意事项
template<typename T>//typename可以替换成class
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
//1.自动类型推导,必须推导出一致数据类型T,才可以使用
void test01()
{
int a = 10;
int b = 20;
char c = 'c';
mySwap(a, b);//正确
//mySwap(a, c);//错误,没有匹配类型模板
cout << "a=" << a << " " << "b=" << b << endl;
}
//2.模板必须要确定出T的数据类型,才可以使用
template<class T>
void func()
{
cout << "func调用" << endl;
}
void test02()
{
//func();//错误!
func<int>();
}
int main()
{
test01();
test02();
return 0;
}
1.2.3函数模板案例
案例描述:
- 利用函数模板封装一个排序的函数,可以对不同数据类型数组进行排序
- 排序从大到小,排序算法为选择排序
- 分别利用char数组和int数组进行测试
#include<iostream>
using namespace std;
//实现通用的 对数组进行排序的函数
//交换函数模板
template<class T>
void mySwap(T& a, T &b)
{
T temp = a;
a = b;
b = temp;
}
//排序算法
template<class T>
void mySort(T arr[],int len)
{
for (int i = 0; i < len; i++)
{
int max = i;//认定的最大值下标
for (int j = i+1; j < len; j++)
{
//认定的数值比 遍历出的数值要小,说明j下标元素才是最大值下标
if (arr[max] < arr[j])
{
max = j;
}
}
if (max != i)
{
//交换max和i元素
mySwap(arr[max], arr[i]);
}
}
}
//提供打印数组的模板
template<class T>
void printArray(T arr[], int len)
{
for (int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
}
void test01()
{
char charArr[] = "badcfe";
int num = sizeof(charArr) / sizeof(char);
mySort<char>(charArr,num );
printArray(charArr, num);
}
int main()
{
test01();
return 0;
}
1.2.4普通函数和函数模板的区别
- 普通函数调用时可以发生自动类型转换(隐式类型转换)
- 函数模板调用时,如果可以利用自动类型推导,不会发生隐式类型转换
- 如果利用显示指定类型的方式,可以发生隐式类型转换
1.3类模板
1.3.1类模板语法
类模板作用:建立一个通用类,类中的成员 数据类型可以不具体判定,用一个虚拟的类型来代表
语法:
template<typrname T>
类
解释:
template——声明创建模板
typename——表面其后面的符号是一种数据类型,可以用class代替
T——通用的数据类型,名称可以替换,通常为大写字母
示例
#include<iostream>
using namespace std;
#include<string>
//类模板
template<class NameType,class AgeType>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "name: " << this->m_Name<<" " << "age: " << this->m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
void test01()
{
Person<string, int>p1("孙悟空",999);//类型参数化
p1.showPerson();
}
int main()
{
test01();
return 0;
}
总结:类模板和函数模板语法相似,在声明模板template后面加类,此类称为类模板
1.3.2类模板和函数模板的区别
1.类模板没有自动类型推导的使用方式
2.类模板再模板参数列表中可以有默认函数
示例:
#include<iostream>
using namespace std;
#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 << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
NameType m_Name;
AgeType m_Age;
};
//1.类模板没有自动类型推导的使用方式
void test01()
{
/*Person p("孙悟空", 1000);错误,无法用自动类型推导*/
Person<string,int> p("孙悟空", 1000);//正确只能用显示指定类型
p.showPerson();
}
//
//2.类模板再模板参数列表中可以有默认函数
//可以直接在设置类模板的时候,指定age为int型,
//即class AgeType=int,则在后续使用类模板实例化时不用再写age的类型
//注意:这种方式仅在类模板中允许使用,函数模板不能
void test02()
{
Person<string> p("猪八戒", 999);
p.showPerson();
}
int main()
{
test01();
test02();
return 0;
}
1.3.3 类模板中成员函数的创建时机
类模板中成员函数和普通类成员函数创建时机是有区别的
- 普通类中的成员函数一开始就可以创建
- 类模板中的成员函数在调用时才可以创建
示例:
#include<iostream>
using namespace std;
//类模板中成员函数创建时机
//普通类中的成员函数一开始就可以创建
//类模板中的成员函数在调用时才可以创建
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();
}
//func1 和 func2只要不去调用,都不会创建,编译不会报错
};
void test01()
{
MyClass<Person1>m;
m.func1();
/*m.func2();*/
}
int main()
{
test01();
return 0;
}
总结:类模板中的成员函数并不是一开始就创建的,在调用时才去创建。
1.3.4类模板对象做函数参数
- 类模板实例化出的对象,向函数传参的方式
三种方式:
1.指定传入类型——直接显示对象数据类型
2.参数模板化——将对象中的参数变为模板进行传递
3.整个类模板化——将这个对象类型 模板化进行传递
示例:
#include<iostream>
#include<string>
using namespace std;
//类模板对象做函数参数
template<class T1,class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//三种方式:
//最常用第一种
//1.指定传入类型——直接显示对象数据类型
void printPerson(Person<string, int>&p)//类模板的对象做函数的参数
{
p.showPerson();
}
void test01()
{
Person<string, int>p("孙悟空", 100);
printPerson(p);
}
//2.参数模板化——将对象中的参数变为模板进行传递
template<class T1,class T2>
void printPerson2(Person<T1,T2>& p)
{
p.showPerson();
//查看T1 T2的类型
cout << "T1的类型为: " << typeid(T1).name() << endl;
cout << "T2的类型为: " << typeid(T2).name() << endl;
}
void test02()
{
Person<string, int>p("猪八戒", 90);
printPerson2(p);
}
//3.整个类模板化——将这个对象类型 模板化进行传递
template<class T>
void printPerson3(T& p)
{
p.showPerson();
cout << "T的类型为: " << typeid(T).name() << endl;
}
void test03()
{
Person<string, int>p("唐僧", 30);
printPerson3(p);
}
int main()
{
test01();
test02();
test03();
return 0;
}
1.3.5 类模板与继承
当类模板碰到继承时,需要注意以下几点:
- 当子类继承的父类是一个类模板时,子类在声明的时候,要指定出父类中T的类型
- 如果想灵活指定出父类中T的类型,子类也需要变为类模板
示例:
#include<iostream>
using namespace std;
//类模板与继承
template<class T>
class Base
{
public:
T m;
};
//class Son :public Base//错误,必须知道T的数据类型才能继承给父类
class Son:public Base<int>
{
};
void test01()
{
Son s1;
}
//如果像灵活地指定父类T的类型,子类也要变成类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
Son2()
{
cout << "T1的类型为: " << typeid(T1).name() << endl;
cout << "T2的类型为: " << typeid(T2).name() << endl;
}
T1 obj;
};
void test02()
{
Son2<int,char> s2;
}
int main()
{
test01();
test02();
return 0;
}
//注意:类模板的成员函数在调用时才会创建
1.3.6 类模板成员函数的类外实现
示例:
#include<iostream>
#include<string>
using namespace std;
//类的声明中只做函数的声明,定义要在定义的.cpp文件写
//在大项目中很多时候类的声明.h和定义.cpp和主函数.cpp都是分开写的
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>//步骤一:加上template说明
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()
{
cout << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
void test01()
{
Person<string, int> p("Tom", 20);
p.showPerson();
}
int main()
{
test01();
return 0;
}
1.3.7 类模板分文件编写
出现问题:
- 类模板中成员函数创建时机是在调用阶段,导致分文件编写时连接不到
解决:
- 方式1:直接包含.cpp源文件
- 方式2:将声明和实现写到同一个文件中,并改后缀名为.hpp,hpp是约定名称,不是强制
示例:
方法1
头文件:Person.h
#pragma once
#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 << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
main.cpp
#include<iostream>
#include<string>
using namespace std;
//方法1,这里使用引用Person.cpp文件而非Person.h文件
#include"Person.cpp"
void test01()
{
Person<string, int>p("Jerry", 18);
p.showPerson();
}
int main()
{
test01();
return 0;
}
方法二(更常用)
在头文件中创建hpp文件(更改后缀名即可):
#pragma once
#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 << "name:" << this->m_Name << " age:" << this->m_Age << endl;
}
main.cpp
#include<iostream>
#include<string>
using namespace std;
//方法2:(常用)将.h和。cpp的内容写到一起将后缀改为.hpp文件
#include"Person.hpp"
void test01()
{
Person<string, int>p("Jerry", 18);
p.showPerson();
}
int main()
{
test01();
return 0;
}
1.3.8 类模板与友元
类模板配合友元函数的类内和类外实现
全局函数类内实现,直接类内声明友元即可;
全局函数类外实现,需要提前让编译器知道全局函数的存在——非常麻烦!!!
示例:
#include<iostream>
using namespace std;
//让编译器提前知道Person类模板的存在
template<class T1, class T2>
class Person;
//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2>p)
{
cout << "类外实现name: " << p.m_Name << " age:" << p.m_Age << endl;
}
template<class T1, class T2>
class Person
{
//全局函数类内实现
friend void printPerson(Person<T1,T2>p)
{
cout << "name: " << p.m_Name << " age:" << p.m_Age << endl;
}
//全局函数类外实现
//这里需要加入一个空模板的参数列表
//如果全局函数是类外实现,需要提前让编译器提前知道这个函数的存在
//——而函数中又又Person类,所以还要让编译器提前知道Person类模板的存在
friend void printPerson2<>(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",20);
printPerson(p);
}
//全局函数类外实现
void test02()
{
Person<string, int> p("Jerry", 20);
printPerson2(p);
}
int main()
{
test01();
test02();
return 0;
}