【C++】泛型编程 ⑧ ( 类模板继承语法 | 普通类 继承 类模板语法 | 类模板 继承 类模板语法 | 继承类模板必须指定具体的类型参数列表 | 继承 类模板 必须重写构造函数 )

一、普通类 继承 类模板语法

---

1、普通类 继承 类模板语法

类模板 作为父类 , 子类 继承 类模板 父类 ,

• 需要 指定 具体的类型参数列表 ;
• 需要 重写 构造函数 , 其中必须调用 类模板 具体类 的构造函数 ;

类模板 父类 :

// 声明 类模板 父类
template <typename T>
class Father {
public:
    T value;
    Father(T val) : value(val) {}
    void printValue() {
        std::cout << value << std::endl;
    }
};

继承了类模板 的 子类 :

// 类模板 继承时 , 需要具体化 类模板
// 也就是 指定 类模板 的 类型参数列表 , 将 泛型类型 固定下来
// C++ 编译器 只有知道了具体类型 , 才能知道 父类占用内存大小
// 才能正确分配内存
class Son : public Father<int>
{
public:
    // 类模板 子类 必须重写构造函数
    // 在 子类 构造函数中 , 调用 类模板 具体类 的构造函数
    // 否则会报错
    Son(int a = 10, int b = 20) : Father<int>(a)
    {
        this->b = b;
    }

public:
    int b;
};

2、继承类模板必须指定具体的类型参数列表

定义 类模板 ,

// 声明 类模板 父类
template <typename T>
class Father {
public:
    T value;
    Father(T val) : value(val) {}
    void printValue() {
        std::cout << value << std::endl;
    }
};

定义 一个子类 , 继承上述类模板 ,

类模板子类 与 普通类子类 区别就是 , 类模板子类 需要在尖括号中指定 具体的 类型参数列表 的 数据类型 ;

此时 , 在继承时 , 被继承的 类模板 必须 声明 类型参数列表 , 将具体的泛型类型写在尖括号中 ,

C++ 编译器需要知道 具体的 数据类型 是什么 , 才能生成 具体的类 ,

只有这样 , 将具体的数据类型固定下来 , C++ 编译器 才能知道 父类 所占的 内存大小 , 才能正确分配内存 ;

否则 , 会报 " error C2955: “Father”: 使用 类 模板 需要 模板 参数列表 " 错误 ;

报错信息如下 :

已启动生成…
1>------ 已启动生成: 项目: HelloWorld, 配置: Debug Win32 ------
1>Test.cpp
1>D:\002_Project\006_Visual_Studio\HelloWorld\HelloWorld\Test.cpp(16,1): error C2955: “Father”: 使用 类 模板 需要 模板 参数列表
1>D:\002_Project\006_Visual_Studio\HelloWorld\HelloWorld\Test.cpp(6): message : 参见“Father”的声明
1>已完成生成项目“HelloWorld.vcxproj”的操作 - 失败。
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========

3、继承 类模板 必须重写构造函数

类模板 子类 必须重写构造函数 , 在 子类 构造函数中 , 调用 类模板 具体类 的构造函数 ,

如果 子类 继承 类模板父类 , 如果 子类没有实现 构造函数 ,

// 类模板 继承时 , 需要具体化 类模板
// 也就是 指定 类模板 的 类型参数列表 , 将 泛型类型 固定下来
// C++ 编译器 只有知道了具体类型 , 才能知道 父类占用内存大小
// 才能正确分配内存
class Son : public Father<int>
{

};

此时 , 声明 子类实例对象 ,

Son son;

会报错 error C2280: “Son::Son(void)”: 尝试引用已删除的函数 ;

已启动生成…
1>------ 已启动生成: 项目: HelloWorld, 配置: Debug Win32 ------
1>Test.cpp
1>D:\002_Project\006_Visual_Studio\HelloWorld\HelloWorld\Test.cpp(26): error C2280: “Son::Son(void)”: 尝试引用已删除的函数
1>D:\002_Project\006_Visual_Studio\HelloWorld\HelloWorld\Test.cpp(22): message : 编译器已在此处生成“Son::Son”
1>D:\002_Project\006_Visual_Studio\HelloWorld\HelloWorld\Test.cpp(22,1): message : “Son::Son(void)”: 由于 基类“Father<int>”不具备相应的 默认构造函数 或重载解决不明确，因此已隐式删除函数
1>D:\002_Project\006_Visual_Studio\HelloWorld\HelloWorld\Test.cpp(19): message : 参见“Father<int>”的声明
1>已完成生成项目“HelloWorld.vcxproj”的操作 - 失败。
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========

4、完整代码示例

代码示例 :

#include "iostream"
using namespace std; 

// 声明 类模板 父类
template <typename T>
class Father {
public:
    T value;
    Father(T val) : value(val) {}
    void printValue() {
        std::cout << value << std::endl;
    }
};

// 类模板 继承时 , 需要具体化 类模板
// 也就是 指定 类模板 的 类型参数列表 , 将 泛型类型 固定下来
// C++ 编译器 只有知道了具体类型 , 才能知道 父类占用内存大小
// 才能正确分配内存
class Son : public Father<int>
{
public:
    // 类模板 子类 必须重写构造函数
    // 在 子类 构造函数中 , 调用 类模板 具体类 的构造函数
    // 否则会报错
    Son(int a = 10, int b = 20) : Father<int>(a)
    {
        this->b = b;
    }

public:
    int b;
};

int main() {

    Son son;
    son.printValue();

    Son son2(666, 888);
    son2.printValue();
	
	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
}

执行结果 :

10
666
Press any key to continue . . .

二、类模板 继承 类模板语法

---

1、类模板 继承 类模板语法

普通类 继承 类模板时 , 需要指定 类模板 的具体 参数类型 , 下面代码中的 具体类型就是 int ;

class Son : public Father<int>

类模板 继承 类模板 时 , 也需要 指定 父类类模板 的具体 泛型类型 , 只是这个泛型类型可以是 另外一个泛型 T ;

下面的代码 是 类模板 继承 类模板的 代码 ,

Son2 中的 泛型 T , 与 Father 中的 T 没有任何关系 ,

也就是说 Son2 中的 泛型类型 T 相当于 普通类 继承 类模板 中的 具体类型 int ,

Father 类中的 泛型 T 已经被覆盖掉了 , 使用 Son2 中的 泛型 T 替代 ;

// 类模板 继承 类模板
template <typename T>
class Son2 : public Father<T>
{
public:
    T c;
    Son2(T c, T val) : Father<T>(val) {
        this->c = c;
    }
    void printC() {
        std::cout << c << std::endl;
    }
};

2、完整代码示例

代码示例 :

#include "iostream"
using namespace std; 

// 声明 类模板 父类
template <typename T>
class Father {
public:
    T value;
    Father(T val) : value(val) {}
    void printValue() {
        std::cout << value << std::endl;
    }
};

// 类模板 继承时 , 需要具体化 类模板
// 也就是 指定 类模板 的 类型参数列表 , 将 泛型类型 固定下来
// C++ 编译器 只有知道了具体类型 , 才能知道 父类占用内存大小
// 才能正确分配内存
class Son : public Father<int>
{
public:
    // 类模板 子类 必须重写构造函数
    // 在 子类 构造函数中 , 调用 类模板 具体类 的构造函数
    // 否则会报错
    Son(int a = 10, int b = 20) : Father<int>(a)
    {
        this->b = b;
    }

public:
    int b;
};

// 类模板 继承 类模板
template <typename T>
class Son2 : public Father<T>
{
public:
    T c;
    Son2(T c, T val) : Father<T>(val) {
        this->c = c;
    }
    void printC() {
        std::cout << c << std::endl;
    }
};

int main() {

    Son son;
    son.printValue();

    Son son0(666, 888);
    son0.printValue();

    Son2<int> son2(66, 88);
    son2.printValue();
    son2.printC();
	
	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
}

执行结果 :

10
666
88
66
Press any key to continue . . .