【C++】泛型编程 ⑫ ( 类模板 static 关键字 | 类模板 static 静态成员 | 类模板使用流程 )

迷南。 2024-02-18 13:47 21阅读 0赞

#### 文章目录 ####

*  一、类模板使用流程
 *   *  1、类模板 定义流程
     *  2、类模板 使用
     *  3、类模板 函数 外部实现
 *  二、类模板 static 关键字
 *   *  1、类模板 static 静态成员
     *  2、类模板 static 关键字 用法
     *  3、完整代码示例

将 类模板 函数声明 与 函数实现 分开进行编码 , 有 三种 方式 :

*  类模板 的 函数声明 与 函数实现 都写在同一个类中 , 也就是没有分开进行编码 ;
 *  类模板 的 函数实现 在 类外部进行 , 函数声明 和 实现 写在相同的 .cpp 源码文件中 ;
 *  类模板 的 函数实现 在 类外部进行 , 函数声明 和 实现 写在不同的 .h 和 .cpp 源码文件中 ;

在博客 [【C++】泛型编程 ⑨ ( 类模板的运算符重载 - 函数声明 和 函数实现 写在同一个类中 | 类模板 的 外部友元函数问题 )][C_ _ _ _ - _ _ _ _ _ _ _ _] 中实现了第一种情况 , **类模板 的 函数声明 与 函数实现 都写在同一个类中 , 也就是没有分开进行编码 ;**

在博客 [【C++】泛型编程 ⑩ ( 类模板的运算符重载 - 函数实现 写在类外部的同一个 cpp 代码中 | 类模板 的 外部友元函数二次编译问题 )][C_ _ _ _ - _ _ cpp _ _ _ _ _] 中 , 分析了 第二种情况 , **类模板 的 函数实现 在 类外部进行 , 写在 一个 cpp 源码文件中** ;

在博客 [【C++】泛型编程 ⑪ ( 类模板的运算符重载 - 函数实现 写在类外部的不同的 .h 头文件和 .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  
请按任意键继续. . .

![在这里插入图片描述][f0fb6fb3b8f04fb0af75529b8f54cedc.png]

[C_ _ _ _ - _ _ _ _ _ _ _ _]: https://hanshuliang.blog.csdn.net/article/details/134510512
[C_ _ _ _ - _ _ cpp _ _ _ _ _]: https://hanshuliang.blog.csdn.net/article/details/134528915
[C_ _ _ _ - _ _ .h _ .cpp _]: https://hanshuliang.blog.csdn.net/article/details/134535423
[f0fb6fb3b8f04fb0af75529b8f54cedc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f43ca4d71f0f4d4cba4c0ab625228274.png