文章目录
- 一、类模板使用流程
- 1、类模板 定义流程
- 2、类模板 使用
- 3、类模板 函数 外部实现
- 二、类模板 static 关键字
- 1、类模板 static 静态成员
- 2、类模板 static 关键字 用法
- 3、完整代码示例
将 类模板 函数声明 与 函数实现 分开进行编码 , 有 三种 方式 :
- 类模板 的 函数声明 与 函数实现 都写在同一个类中
- 类模板 的 函数实现 在 类外部进行 , 函数声明 和 实现 写在相同的 .cpp 源码文件中 ;
- 类模板 的 函数实现 在 类外部进行 , 函数声明 和 实现 写在不同的 .h 和 .cpp 源码文件中 ;
在博客 【C++】泛型编程 ⑨ ( 类模板的运算符重载 - 函数声明 和 函数实现 写在同一个类中 | 类模板 的 外部友元函数问题 ) 中实现了第一种情况 , 类模板 的 函数声明 与 函数实现 都写在同一个类中 , 也就是没有分开进行编码 ;
在博客 【C++】泛型编程 ⑩ ( 类模板的运算符重载 - 函数实现 写在类外部的同一个 cpp 代码中 | 类模板 的 外部友元函数二次编译问题 ) 中 , 分析了 第二种情况 , 类模板 的 函数实现 在 类外部进行 , 写在 一个 cpp 源码文件中 ;
在博客 【C++】泛型编程 ⑪ ( 类模板的运算符重载 - 函数实现 写在类外部的不同的 .h 头文件和 .cpp 代码中 ) 中 , 分析 第三种 情况 , 函数实现 在 类外部进行 , 函数声明 和 实现 写在不同的 .h 和 .cpp 源码文件中 ;
一、类模板使用流程
1、类模板 定义流程
类模板 定义流程 :
- 首先 , 定义一个 使用 实际数据类型 的类 , 这里的数据类型 指的是 成员变量类型 或 成员函数 参数或返回值 类型 ; 这些类型 由于是 实际类型 , 语义明确 , 含义清楚 , 不会报错 ;
- 然后 , 将 要使用 泛型模板 的 类型 , 改为一个 自己定义的 虚拟泛型类型 , 如 :
template <typename T>中的 T 类型 ; - 最后 , 在 类声明 前面加上
template <typename T>, 其中的 T 类型可以改为其它字母代替 , 一般是大写字母 ;
2、类模板 使用
使用类模板 : 使用 类模板 创建实例对象时 , 首先要注明 具体类型 , 生成具体类 , 才能创建具体类的 实例对象 , 语法格式如下 ;
类模板名称<实际类型名称> 对象名称;
类模板名称<实际类型名称> 对象名称(构造函数实参列表);以 上一篇博客的 Student 类模板为例 , 创建 Student 类模板实例对象示例如下 ;
Student<int> s;
Student<int> s(1, 2);
3、类模板 函数 外部实现
如果要在 类模板 之外 实现 类模板中的 成员函数 ,
首先 , 要 声明 类模板 的类型参数 ;
template <typename 类型参数列表>然后 , 使用 域操作符 :: 访问类模板中的函数 , 访问时需要 注明 类模板的 实际参数类型 ;
函数返回值类型 类模板名称<实际参数类型列表>::成员函数名(函数形参列表)
{
}特别注意 , 如果上面的类型中 , 涉及到的 函数返回值类型 或 函数形参列表 中 , 有 类模板类型 , 也要注明 实际的参数类型 ;
如下面的 operator+ 函数 ,
template <typename T>
class Student
{
public:
// 重载 + 运算符
Student operator+(Student& s);
};在 类模板 外部 实现上述 函数声明 , 就需要使用如下方式 ;
// 重载 + 运算符
// 使用 Student<T>:: 域操作符访问函数
template <typename T>
Student<T> Student<T>::operator+(Student<T>& s)
{
// 函数内部的类的 <T> 模板类型 , 可加 Student<T> 可不加 Student
// 不加 <T> 也可以使用 , 加了也不会报错
Student student(this->a + s.a, this->b + s.b);
return student;
}
二、类模板 static 关键字
1、类模板 static 静态成员
类模板中 , 定义了 static 静态成员变量 ;
静态 成员变量 是属于整个类的 , 但是对于 类模板 来说 , 存在着二次编译 , 会生成多个不同的实际类 ;
类模板 的 实际类型 可能有多种 , 如 Student<int> 和 Student<double> 是两个具体的实际类型 , C++ 编译器会将 类模板 编译成 两个不同的 类 ;
上述 编译成的 不同的类 , 每个类 都有一个 static 静态成员 , 相互之间是独立的 ;
2、类模板 static 关键字 用法
类模板 static 关键字 用法 :
首先 , 在 类模板 中 , 声明 static 静态成员 ;
template <typename T>
class Student
{
public:
// 类模板中的静态成员
static T m_a;
};然后 , 在类外部 , 初始化静态成员 , 之后才能 使用该静态成员 , 使用 静态成员 时 , 要声明 类模板 类型 template <typename T> , 下面使用 域作用符 访问时 , 需要注明 类模板类型 ;
// 初始化静态成员
template <typename T>
T Student<T>::m_a = 0;最后 , 使用 类模板 中的静态成员时 , 每个 生成的 具体类型 , 都有一个独立互不干扰的 静态成员 ; 下面 Student<int> 类型的对象 s1 , s2 共享 静态成员 m_a , Student<double> 类型的对象 s3 , s4 共享 静态成员 m_a ; s1 和 s3 是不同的静态成员 ;
Student<int> s1, s2;
Student<double> s3, s4;
3、完整代码示例
代码示例 :
#include "iostream"
using namespace std;
template <typename T>
class Student
{
public:
// 类模板中的静态成员
static T m_a;
};
// 初始化静态成员
template <typename T>
T Student<T>::m_a = 0;
int main() {
Student<int> s1, s2;
cout << "s1, s2 赋值前 : s1.m_a : " << s1.m_a << " , s2.m_a : " << s2.m_a << endl;
s1.m_a = 6;
cout << "s1, s2 赋值后 : s1.m_a : " << s1.m_a << " , s2.m_a : " << s2.m_a << endl;
Student<double> s3, s4;
cout << "s3, s4 赋值前 : s3.m_a : " << s3.m_a << " , s4.m_a : " << s4.m_a << endl;
s3.m_a = 8;
cout << "s3, s4 赋值后 : s1.m_a : " << s1.m_a << " , s2.m_a : " << s2.m_a << endl;
cout << "s3, s4 赋值后 : s3.m_a : " << s3.m_a << " , s4.m_a : " << s4.m_a << endl;
// 控制台暂停 , 按任意键继续向后执行
system("pause");
return 0;
}执行结果 :
s1, s2 赋值前 : s1.m_a : 0 , s2.m_a : 0
s1, s2 赋值后 : s1.m_a : 6 , s2.m_a : 6
s3, s4 赋值前 : s3.m_a : 0 , s4.m_a : 0
s3, s4 赋值后 : s1.m_a : 6 , s2.m_a : 6
s3, s4 赋值后 : s3.m_a : 8 , s4.m_a : 8
请按任意键继续. . .
