模版
C++的泛型编程
可以将数据类型作为参数进行传递
关键字:
C++模版的语法使用"<>"来表示泛型类型,并使用关键字template来定义和声明模版
分类:
模版函数
模版类
模版函数
语法:
template<class 假设的类型1,class 假设的类型2,.......>
或
template<typename 假设的类型1,typename 假设的类型2,.......>
返回值类型 函数名(形参列表)
{
函数体
}
注意:
当前函数中任何一处使用数据类型的地方都可以使用假设的类型
class 也可以替换为 typename
特点:
1,函数模版可以自动推导参数的类型,但是不会进行类型转换
2,函数模版可以自动类型推导,也可以显式指定类型
显式指定类型
函数名<指定的类型1,指定的类型2,...>(实参列表);
3,只能在声明的所在函数中使用
补充:
函数模板会经历两次编译：第一次是在加载时对函数模板本身进行编译，第二次是在函数被调用时，编译器根据所推导出来的 T 的类型，再次对函数模板进行编译，从而生成模板函数。
如:
template<class X,class Y>
Y add(X x,Y,x)
{
Y sum = (Y)(x+y);
return sum;
}
char a = add(1,'A');
如:template<class X,class Y>
Y add(X x,Y,x)
{
Y sum = (Y)(x+y);
return sum;
}
char a = add<int,char>(1,'A');
模版函数与普通函数的区别
1,函数模版不允许自动类型转换,普通函数能够自动进行类型转换
2,函数模版和普通函数同时识别,优先使用普通函数,加<>强制使用函数模版
3,函数模版可以使用<>,普通函数不行
函数模版的局限性
#include <iostream>
using namespace std;
template <class T>
void method(T t)
{
cout<<t<<endl;
}
class A{};
int main()
{
method(10);
A a;
method(a);//此时模版可以推导出T的类型为A,但是A类没有重载<<运算符,所以无法通过cout输出,此时语法无错,但是无法编译生成可执行文件
return 0;
}
解决方法1:重载<<运算符
#include <iostream>
using namespace std;
template <class T>
void method(T t)
{
cout<<t<<endl;
}
class A{};
ostream& operator<<(ostream& out,A& a)
{
out<<"打印A的对象"<<endl;
return out;
}
int main()
{
method(10);
A a;
method(a);
return 0;
}
解决方法2:指定模版函数
#include <iostream>
using namespace std;
template <class T>
void method(T t)
{
cout<<t<<endl;
}
class A{};
//指定模版函数
template<> void method<A>(A a)
{
cout<<"打印A的对象"<<endl;
}
int main()
{
method(10);
A a;
method(a);
return 0;
}
类模版
概念:有模板的类
语法:
template<class 假设的类型1,class 假设的类型2,...>
class 类名:继承方式 父类名1,...
{
};
作用:当前类中任何一处使用数据类型的地方都可以使用假设的类型
创建对象:
类名<类型1,类型2,...> 对象名(实参列表);
类名<类型1,类型2,...> *对象名 = new 类名<类型1,类型2>(实参列表);
模版类作为父类
方案1:子类指明父类模版类型
方案2:子类也是模版类
模版类的函数声明与实现分离
注意
每一个类外实现的函数都是模版函数
template <class 假设的类型>
返回值类型 类名<假设的类型>::函数名(形参列表)
{
}
#include<iostream>using namespace std;
template <class Q>
class Data
{
private:
Q q;
public:
Data();
Data(Q q);
Q getQ();
void setQ(Q q);
};
template <class x>
Data<x>::Data()
{
}
template<class Q>
Data<Q>::Data(Q q)
{
this->q = q;
}
template<class Q>
Q Data<Q>::getQ()
{
return q;
}
template<class Q>
void Data<Q> ::setQ(Q q)
{
this->q = q;
}
int main()
{
Data<int> data(10);
return 0;
}
hpp文件
因为模版类的声明与实现无法分离
故将模版类的声明与实现放在同一个文件中,该文件后缀名为.hpp
类模版对象作为形参
#include <iostream>
#include <iomanip>
// 类模板定义，模拟一个简单的数组类
template<typename T, int size>
class MyArray {
private:
T elements[size];
public:
MyArray() {}
// 给数组元素赋值的函数
void setElement(int index, T value) {
if (index >= 0 && index < size) {
elements[index] = value;
}
}
// 获取数组元素的函数
T getElement(int index) {
if (index >= 0 && index < size) {
return elements[index];
}
return T();
}
};
// 函数，以类模板MyArray的对象作为形参，计算数组中所有元素的和
template<typename T, int size>
T sumElements(MyArray<T, size> arr) {
T sum = T();
for (int i = 0; i < size; ++i) {
sum += arr.getElement(i);
}
return sum;
}
int main() {
// 实例化一个存储int类型元素，大小为5的MyArray对象
MyArray<int, 5> intArray;
for (int i = 0; i < 5; ++i) {
intArray.setElement(i, i + 1);
}
// 调用sumElements函数，传入MyArray对象，计算元素和并输出
int sum = sumElements(intArray);
std::cout << "The sum of elements in the array is: " << sum << std::endl;
return 0;
}
类型转换
C语言提供的强制类型转换
语法 :( 转换后的类型 ) 要转换的数据或变量
静态转换
static_cast<T>( 要转换的数据)
// 基本类型转换 支持
int num = static_cast < int > ( 3.14f );
// 基本指针类型转换 不支持
float f = 0.0f ;
//int *p1 = static_cast<int *>(&f);
// 上行转换 支持（安全）
Base * p2 = static_cast < Base *> ( new Son );
// 下行转换 支持（不安全）
Son * p3 = static_cast < Son *> ( new Base );
// 不相关类型转换 不支持
//Son *p4 = static_cast<Son *>(new Other);
动态类型转换
dynamic_cast<T>( 要转换的数据)
// 基本类型转换 不支持
//int num = dynamic_cast<int>(3.14f);
// 基本指针类型转换 不支持
float f = 0.0f ;
//int *p1 = dynamic_cast<int *>(&f);
// 上行转换 支持（安全）
Base * p2 = dynamic_cast < Base *> ( new Son );
// 下行转换 不支持（不安全）
//Son *p3 = dynamic_cast<Son *>(new Base);
// 不相关类型转换 不支持
//Son *p4 = dynamic_cast<Son *>(new Other);
常量转换
const_cast<T>
只能对指针与引用的变量使用// 将非 const 转换成 const
int num = 10 ;
const int * p1 = const_cast < const int * > ( & num );
// 将 const 转换成 非 const
const int data = 0 ;
int * p = const_cast < int * > ( & data );
重新解释转换
这是最不安全的一种转换机制，最有可能出问题。
主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个
整数，也可以将一个整数转换成一个指针.语法:
reinterpret_cast<T>
// 基本类型转换 不支持
//int num = reinterpret_cast<int>(3.14f);
// 基本指针类型转换 支持
float f=0.0f;
int *p1 = reinterpret_cast<int *>(&f);
// 上行转换 支持（安全）
Base *p2 = reinterpret_cast<Base *>(new Son);
// 下行转换 支持（不安全）
Son *p3 = reinterpret_cast<Son *>(new Base);
// 不相关类型转换 支持
Son *p4 = reinterpret_cast<Son *>(new Other);