C++ 类模板教程

C++ 的类模板是泛型编程的焦点特性之一, 它让我们能够编写适用于多种范例的通用代码, 从而提高代码的复用性和扩展性.
本教程通过栈的实现为例, 深入探讨类模板的实现, 使用, 以及特化, 偏特化, 默认参数和范例别名等高级特性, 资助您更全面地掌握这一强盛工具.
1. 实现一个 Stack

笔者选择用一个栈的模板来做演示, 由于栈的接口和功能相对而言比较简朴. Stack模板支持如下操纵:

• Push: 入栈一个元素
  
• Pop: 弹出一个元素
  
• Top: 获取栈顶的元素
  
• Empty: 栈是否为空
  
• Size: 栈的元素数量
  

实现代码array.hpp

1. template <typename T>
2. class Stack {
3. private:
4.   T* data_ = nullptr;
5.   size_t capacity_ = 10; // 原始的空间为10
6.   size_t length_ = 0;
8.   void resize(size_t new_capacity) {
9.     T* new_data = new T[new_capacity];
10.     for (size_t i = 0; i < length_; ++i) {
11.       new_data[i] = data_[i];
12.     }
13.     delete[] data_;
14.     data_ = new_data;
15.     capacity_ = new_capacity;
16.   }
18. public:
19.   Stack() { data_ = new T[capacity_]; }
21.   ~Stack() { delete[] data_; }
23.   void Push(const T& value) {
24.     if (length_ == capacity_) {
25.       resize(capacity_ * 2);
26.     }
27.     data_[length_++] = value;
28.   }
30.   void Pop() {
31.     if (length_ == 0) {
32.       throw std::out_of_range("Index out of range");
33.     }
34.     --length_;
35.   }
37.   [[nodiscard]] size_t Size() const { return length_; }
39.   [[nodiscard]] bool Empty() const { return length_ == 0; }
41.   T Top() const {
42.     if (0 == length_) {
43.       throw std::out_of_range("Index out of range");
44.     }
45.     return data_[length_ - 1];
46.   }
47. };

复制代码

从上面的代码可以看到

• 模板类相比平凡类多了一个泛型声明: template <typename T>
  
• 在模板类的内部, 数据成员大概函数成员都可用使用泛型T
  
• 类模板的实现通常是在一个头文件中, 不需要像平凡类举行头文件/源文件分离.
  

---

2. 如何使用类模板

下面是一个简朴的例子, 演示如何使用 Stack 类模板. 用法跟 STL 库中的容器类使用非常相似, 雷同std::vector.

1. Stack<int> arr;
3. arr.Push(10);
4. arr.Push(20);
5. arr.Push(30);
7. std::cout << "Stack size: " << arr.Size() << std::endl;
8. std::cout << "Stack top: " << arr.Top() << std::endl;
10. arr.Pop();
11. std::cout << "After Pop, size: " << arr.Size() << std::endl;
12. std::cout << "Stack top: " << arr.Top() << std::endl;

复制代码

---

3. 类模板的特化

类模板的特化可以为特定范例提供专门的实现.
例如, 为 bool 范例特化 Stack.
用一个 bit表现 bool 值, 这样就可以节省许多存储空间.

1. template <>
2. class Stack<bool> {
3. private:
4.   uint8_t* data_ = nullptr;
5.   size_t capacity_ = 10;
6.   size_t length_ = 0;
8.   void resize(size_t new_capacity) {
9.     auto* new_data = new uint8_t[new_capacity];
10.     for (size_t i = 0; i < length_; ++i) {
11.       new_data[i] = data_[i];
12.     }
13.     delete[] data_;
14.     data_ = new_data;
15.     capacity_ = new_capacity;
16.   }
18. public:
19.   Stack() { data_ = new uint8_t[(capacity_ + 7) / 8]; }
20.   ~Stack() { delete[] data_; }
22.   [[nodiscard]] size_t Size() const { return length_; }
23.   [[nodiscard]] bool Empty() const { return length_ == 0; }
25.   void Push(bool value) {
26.     if (length_ == capacity_) {
27.       resize(capacity_ * 2);
28.     }
29.     size_t byte_index = length_ / 8;
30.     size_t bit_index = length_ % 8;
31.     if (value) {
32.       data_[byte_index] |= (1 << bit_index);
33.     } else {
34.       data_[byte_index] &= ~(1 << bit_index);
35.     }
36.     ++length_;
37.   }
39.   void Pop() {
40.     if (0 == length_) {
41.       throw std::out_of_range("Index out of range");
42.     }
43.     --length_;
44.   }
46.   [[nodiscard]] bool Top() const {
47.     if (0 >= length_) {
48.       throw std::out_of_range("Index out of range");
49.     }
50.     size_t byte_index = (length_ - 1) / 8;
51.     size_t bit_index = (length_ - 1) % 8;
52.     uint8_t result = (data_[byte_index] >> bit_index) & 1;
53.     return result == 1;
54.   }
55. };

复制代码

---

4. 类模板的偏特化

偏特化答应对部分模板参数提供专门实现. 例如, Stack 类针对指针范例的偏特化.
留意: 这个偏特化的实现是假定了Stack对与入栈的指针具有所有权, Stack在析构的时间会开释栈内的指针.

1. template <typename T>
2. class Stack<T*> {
3. private:
4.   T** data_ = nullptr;
5.   size_t capacity_ = 10;
6.   size_t length_ = 0;
8.   void resize(size_t new_capacity) {
9.     auto* new_data = new T*[new_capacity];
10.     for (size_t i = 0; i < length_; ++i) {
11.       new_data[i] = data_[i];
12.     }
13.     delete[] data_;
14.     data_ = new_data;
15.     capacity_ = new_capacity;
16.   }
18. public:
19.   Stack() { data_ = new T*[capacity_]; }
21.   ~Stack() {
22.     for (size_t i = 0; i < length_; ++i) {
23.       delete data_[i];
24.     }
25.     delete[] data_;
26.   }
27.   void Push(T* value) {
28.     if (length_ == capacity_) {
29.       resize(capacity_ * 2);
30.     }
31.     data_[length_++] = value;
32.   }
33.   void Pop() { length_--; }
34.   T* Top() { return data_[length_ - 1]; }
35.   [[nodiscard]] size_t Size() const { return length_; }
36.   [[nodiscard]] bool Empty() const { return length_ == 0; }
37. };

复制代码

对比总结

特性特化偏特化作用范围单一具体范例(如 bool)一类范例(如 T*, std::vector<T>)实现独立性独立于通用模板通常继续通用模板的逻辑使用复杂性较简朴较复杂, 需要匹配模板参数模式应用场景对单一范例需求的特殊优化针对一类范例需求的共性优化

---

5. 类模板默认参数

观察上面的代码, 我们会发现有个题目是默认的大小是写死的. 这个多少有些不机动, 我们可以增加一个模板参数, 来决定栈预留空间.

1. // 模板类 Array 的一般实现
2. template <typename T, size_t N = 10>
3. class Stack {
4. private:
5.   T* data_ = nullptr;
6.   size_t capacity_ = N;
7.   size_t length_ = 0;
9.   // 其他代码不变
10. };

复制代码

---

6. 类模板 type alias

通过 using 创建模板范例别名:

1. #include "stack.hpp"
2. using IntStack = Stack<int>;
4. int main() {
5.   IntStack stack;
6.   stack.Push(1);
7. }

复制代码

---

总结

本教程从基础到高级应用, 具体解说了 C++ 类模板的实现与特性. 盼望这些内容能资助您更好地明白并应用类模板.
源码链接

源码链接

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。