C++ 巩固基础之二

发表于 阅读次数：112 评论数： 本文字数： 3k 阅读时长 ≈ 3 分钟

大纲

类、对象、指针

类与对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
#include <cstring>

using namespace std;

const int NAME_LENGTH = 50;

class CGoods {

public:
    CGoods(const char *name, double price, int amount) {
        strcpy(this->_name, name);
        this->_price = price;
        this->_amount = amount;
    }

    const char *getName() const {
        return this->_name;
    }

    double getPrice() const {
        return this->_price;
    }

    int getAmount() const {
        return this->_amount;
    }

    void setName(char *name) {
        strcpy(this->_name, name);
    }

    void setPrice(double price) {
        this->_price = price;
    }

    void setAmount(int amount) {
        this->_amount = amount;
    }

    void show() {
        cout << "name: " << this->_name << endl;
        cout << "price: " << this->_price << endl;
        cout << "amount: " << this->_amount << endl;
    }

private:
    char _name[NAME_LENGTH]; // 静态分配内存
    double _price;
    int _amount;

};

int main() {
    CGoods good("Book", 80, 3);
    good.show();
    return 0;
}

程序执行后的输出结果：

1
2
3
name: Book
price: 80
amount: 3

提示

类的成员函数一经编译，在所有函数的参数列表中，都会隐式自动添加一个 this 指针，用于接收调用该函数的对象的地址。这样在函数被调用时，C++ 才知道是谁调用了该函数。

指向类成员的指针

指向类成员变量的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>

using namespace std;

class Test {

public:
    int ma;
    static int mb;

};

// 初始化类成员静态变量
int Test::mb = 50;

void test01() {
    Test t1;    // 栈上分配内存
    Test *t2 = new Test();  // 堆上分配内存

    // 错误写法
    // int * p = &Test::ma;

    // 指向类成员变量的指针
    int Test::*p = &Test::ma;

    // 通过指针访问类成员变量
    t1.*p = 20;
    cout << t1.ma << ", " << t1.*p << endl;

    // 通过指针访问类成员变量
    t2->*p = 30;
    cout << t2->ma << ", " << t2->*p << endl;

    delete t2;
}

void test02() {
    // 正确写法, 指向类成员静态变量的指针
    int *p1 = &Test::mb;

    // 通过指针访问类成员静态变量
    *p1 = 60;
    cout << Test::mb << ", " << *p1 << endl;
}

int main() {
    test01();
    test02();
    return 0;
}

程序执行后的输出结果：

1
2
3
20, 20
30, 30
60, 60

指向类成员函数的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream>

using namespace std;

class Test {

public:
    void func() {
        cout << "call Test::func" << endl;
    }

    static void static_func() {
        cout << "call Test::static_func" << endl;
    }
};

void test01() {
    Test t1;    // 栈上分配内存
    Test *t2 = new Test();  // 堆上分配内存

    // 错误写法
    // void (*pFunc)() = &Test::func;

    // 指向类成员函数的指针（函数指针）
    void (Test::*pFunc)() = &Test::func;

    // 通过指针调用类成员函数
    (t1.*pFunc)();

    // 通过指针调用类成员函数
    (t2->*pFunc)();
}

void test02() {
    // 正确写法, 指向类成员静态函数的指针（函数指针）
    void (*pStaticFunc)() = &Test::static_func;

    // 通过指针调用类成员静态函数
    (*pStaticFunc)();
}

int main() {
    test01();
    test02();
    return 0;
}

程序执行后的输出结果：

1
2
3
call Test::func
call Test::func
call Test::static_func

构造函数与析构函数

  • 构造函数
    • 定义对象时，构造函数会自动调用。
    • 构造函数是可以重载的，可以有多个构造函数。
    • 对象构造完成后，对象就产生了。
  • 析构函数
    • 析构函数不带参数，不能重载，有且只有一个析构函数。
    • 对象析构完成后，对象就不存在了。
  • 二者的共同点
    • 当开发者没有自定义构造函数和析构函数时，编译器会自动生成一个默认构造函数（无参构造函数）和默认析构函数。

提示

  • 在栈上分配内存空间的 C++ 对象（比如 SeqStack s;），当该对象出了作用域之后（比如函数执行结束之后），C++ 会自动调用该对象的析构函数来释放内存空间。
  • 在堆上分配内存空间的 C++ 对象（比如 SeqStack *s = new SeqStack();），那么必须在该对象出了作用域之前（比如函数执行结束之前），手动执行 delete 操作来释放内存空间，这样该对象的析构函数才会被调用。

下面将实现一个顺序栈的数据结构，并结合构造函数与析构函数一起使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <iostream>

using namespace std;

// 顺序栈
class SeqStack {

public:
    // 构造函数
    SeqStack(int size = 10) {
        cout << "call SeqStack()" << endl;
        // 分配内存
        _pstatck = new int[size];
        _top = -1;
        _size = size;
    }

    // 析构函数
    ~SeqStack() {
        cout << "call ~SeqStack()" << endl;
        // 释放内存
        if (_pstatck != nullptr) {
            delete[] _pstatck;
            _pstatck = nullptr;
        }
    }

    // 入栈
    void push(int val) {
        if (full()) {
            resize();
        }
        _pstatck[++_top] = val;
    }

    // 弹栈
    void pop() {
        if (empty()) {
            return;
        }
        --_top;
    }

    // 获取栈顶元素
    int top() {
        return _pstatck[_top];
    }

    // 栈是否满了
    bool full() {
        return _top == _size - 1;
    }

    // 栈是否为空
    bool empty() {
        return _top == -1;
    }

private:
    int *_pstatck; // 动态开辟数组，存储顺序栈的元素
    int _top;   // 指向栈顶元素的位置
    int _size;  // 数组的总大小

    // 扩容操作
    void resize() {
        // 分配新的内存空间
        int *pnew = new int[_size * 2];
        for (int i = 0; i < _size; i++) {
            pnew[i] = _pstatck[i];
        }
        // 释放旧的内存空间
        delete[] _pstatck;
        // 指向新的内存空间
        _pstatck = pnew;
        _size *= 2;
    }
};

void test01() {
    cout << "===== call test01() =====" << endl;
    
    SeqStack s(5);
    for (int i = 0; i < 15; i++) {
        s.push(rand() % 100);
    }

    while (!s.empty()) {
        cout << s.top() << " ";
        s.pop();
    }
    cout << endl;
}

void test02() {
    cout << "===== call test02() =====" << endl;

    SeqStack *s = new SeqStack(5);
    for (int i = 0; i < 15; i++) {
        s->push(rand() % 100);
    }

    while (!s->empty()) {
        cout << s->top() << " ";
        s->pop();
    }
    cout << endl;

    delete s;
}

int main() {
    // 设置随机数种子
    srand(time(nullptr));

    test01();
    test02();
    return 0;
}

程序执行后的输出结果：

1
2
3
4
5
6
7
8
===== call test01() =====
call SeqStack()
20 40 33 74 97 39 83 65 85 16 48 55 89 22 48 
call ~SeqStack()
===== call test02() =====
call SeqStack()
15 92 64 83 46 74 70 93 54 69 9 46 88 94 39 
call ~SeqStack()

对象的深拷贝和浅拷贝

使用案例一

下面将实现一个顺序栈的数据结构，并结合拷贝构造函数、深拷贝与赋值运算符重载一起使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include <iostream>

using namespace std;

// 顺序栈
class SeqStack {

public:
    // 构造函数
    SeqStack(int size = 10) {
        cout << "call SeqStack()" << endl;
        // 分配内存
        _pstatck = new int[size];
        _top = -1;
        _size = size;
    }

    // 析构函数
    ~SeqStack() {
        cout << "call ~SeqStack()" << endl;
        // 释放内存
        if (_pstatck != nullptr) {
            delete[] _pstatck;
            _pstatck = nullptr;
        }
    }

    // 拷贝构造函数
    SeqStack(const SeqStack &stack) {
        cout << "call SeqStack(const SeqStack &stack)" << endl;
        // 深拷贝（重新分配内存）
        _pstatck = new int[stack._size];
        for (int i = 0; i < stack._size; i++) {
            _pstatck[i] = stack._pstatck[i];
        }
        _top = stack._top;
        _size = stack._size;
    }

    // 运算符重载
    SeqStack &operator=(const SeqStack &stack) {
        cout << "call operator=(const SeqStack &stack)" << endl;
        // 防止自赋值
        if (this == &stack) {
            return *this;
        }

        // 释放原来占用的内存空间
        if (_pstatck != nullptr) {
            delete[]_pstatck;
        }

        // 深拷贝（重新分配内存）
        _pstatck = new int[stack._size];
        for (int i = 0; i < stack._size; i++) {
            _pstatck[i] = stack._pstatck[i];
        }
        _top = stack._top;
        _size = stack._size;

        return *this;
    }

    // 入栈
    void push(int val) {
        if (full()) {
            resize();
        }
        _pstatck[++_top] = val;
    }

    // 弹栈
    void pop() {
        if (empty()) {
            return;
        }
        --_top;
    }

    // 获取栈顶元素
    int top() {
        return _pstatck[_top];
    }

    // 栈是否满了
    bool full() {
        return _top == _size - 1;
    }

    // 栈是否为空
    bool empty() {
        return _top == -1;
    }

    // 打印所有元素
    void print() {
        for (int i = 0; i < _size; i++) {
            cout << _pstatck[i] << " ";
        }
        cout << endl;
    }

    // 获取元素数量
    int size() {
        return _size;
    }

private:
    int *_pstatck; // 动态开辟数组，存储顺序栈的元素
    int _top;   // 指向栈顶元素的位置
    int _size;  // 数组的总大小

    // 扩容操作
    void resize() {
        // 分配新的内存空间
        int *pnew = new int[_size * 2];
        for (int i = 0; i < _size; i++) {
            pnew[i] = _pstatck[i];
        }
        // 释放旧的内存空间
        delete[] _pstatck;
        // 指向新的内存空间
        _pstatck = pnew;
        _size *= 2;
    }
};

int main() {
    // 设置随机数种子
    srand(time(nullptr));

    SeqStack s1(10);
    for (int i = 0; i < s1.size(); i++) {
        s1.push(rand() % 100);
    }
    s1.print();

    SeqStack s2 = s1;   // 默认会调用拷贝构造函数
    s2.print();

    SeqStack s3(s1);   // 默认会调用拷贝构造函数
    s3.print();

    s2 = s3;  // 赋值运算，不会调用拷贝构造函数，默认是浅拷贝，会发生内存泄漏（内存没有被正确释放），解决办法是通过运算符重载来实现深拷贝
    return 0;
}

程序执行后的输出结果：

1
2
3
4
5
6
7
8
9
10
call SeqStack()
88 95 94 93 13 7 9 86 43 10 
call SeqStack(const SeqStack &stack)
88 95 94 93 13 7 9 86 43 10 
call SeqStack(const SeqStack &stack)
88 95 94 93 13 7 9 86 43 10 
call operator=(const SeqStack &stack)
call ~SeqStack()
call ~SeqStack()
call ~SeqStack()

使用案例二

下面将实现一个循环队列的数据结构，并结合拷贝构造函数、深拷贝与赋值运算符重载一起使用。

  • 循环队列的关键特性：

    • 队列特性： 循环队列仍然遵循 “先进先出”（FIFO）的原则。
    • 循环特性： 当队尾指针到达数组末尾时，如果队列未满，则可以循环到数组开头继续插入新元素。
    • 队空与队满条件： 为了区分队列是空还是满，循环队列通常会牺牲一个数组元素的存储空间：
    • 队列为空的条件：front == rear
    • 队列为满的条件：(rear + 1) % capacity == front

  • 循环队列的应用场景：

    • 缓冲区：在生产者 / 消费者模型中用作环形缓冲区。
    • 流量控制：如网络数据包的接收缓冲区。
    • 任务调度：在任务管理系统中，存储循环调度任务。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#include <iostream>

using namespace std;

// 循环队列
class MyQueue {

public:
    MyQueue(int size = 20) {
        _pQueue = new int[size];
        _front = 0;
        _rear = 0;
        _size = size;
    }

    // 删除拷贝构造函数，不让用户调用
    // MyQueue(const MyQueue &other) = delete;

    // 拷贝构造函数
    MyQueue(const MyQueue &other) {
        _front = other._front;
        _rear = other._rear;
        _size = other._size;
        _pQueue = new int[_size];
        for (int i = _front; i != _rear; i = (i + 1) % _size) {
            _pQueue[i] = other._pQueue[i];
        }
    }

    // 删除赋值运算符，不让用户调用
    // MyQueue &operator=(const MyQueue &other) = delete;

    // 赋值运算符重载
    MyQueue &operator=(const MyQueue &other) {
        if (this == &other) {
            return *this;
        }

        if (_pQueue != nullptr) {
            delete[]_pQueue;
        }

        _front = other._front;
        _rear = other._rear;
        _size = other._size;
        _pQueue = new int[_size];
        for (int i = _front; i != _rear; i = (i + 1) % _size) {
            _pQueue[i] = other._pQueue[i];
        }

        return *this;
    }

    ~MyQueue() {
        if (_pQueue != nullptr) {
            delete[] _pQueue;
            _pQueue = nullptr;
        }
    }

    // 入队操作
    void push(int value) {
        if (full()) {
            resize();
        }
        _pQueue[_rear] = value;
        // 循环队列
        _rear = (_rear + 1) % _size;
    }

    // 出队操作
    void poll() {
        if (empty()) {
            return;
        }
        // 循环队列
        _front = (_front + 1) % _size;
    }

    // 返回队头元素
    int front() {
        return _pQueue[_front];
    }

    // 队列是否已满
    bool full() {
        return (_rear + 1) % _size == _front;
    }

    // 队列是否为空
    bool empty() {
        return _front == _rear;
    }

private:
    int *_pQueue;   // 队列的内存空间
    int _front;     // 队头的位置
    int _rear;      // 队尾的位置
    int _size;      // 队列的大小

    // 扩容操作
    void resize() {
        int index = 0;
        int *pTemp = new int[_size * 2];
        // 循环队列
        for (int i = _front; i != _rear; i = (i + 1) % _size) {
            pTemp[index++] = _pQueue[i];
        }
        delete[] _pQueue;
        _pQueue = pTemp;
        _size *= 2;
        _front = 0;
        _rear = index;
    }
};

int main() {
    // 设置随机数种子
    srand(time(nullptr));

    // 调用普通构造函数
    MyQueue q1;
    for (int i = 0; i < 20; i++) {
        q1.push(rand() % 100);
    }

    // 调用拷贝构造函数
    MyQueue q2(q1);

    // 赋值运算符重载
    MyQueue q3;
    q3 = q1;

    while (!q3.empty()) {
        cout << q3.front() << " ";
        q3.poll();
    }
    cout << endl;
    return 0;
}

程序执行后的输出结果：

1
44 71 16 21 11 75 28 29 40 81 86 28 35 43 99 37 45 66 81 53

构造函数的初始化列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <iostream>
#include <cstring>

using namespace std;

class CDate {

public:
    // 自定义一个构造函数，编译器不会再自动生成一个默认构造函数（无参构造函数）
    CDate(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }

    void show() {
        cout << "year: " << _year << ", month: " << _month << ", day: " << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

class CGoods {

public:
    // 使用构造函数的初始化列表，可以指定当前对象的成员变量的初始化方式
    CGoods(const char *name, int amount, double price, int year, int month, int day) : _amount(amount), _price(price), _date(year, month, day) {
        strcpy(_name, name);
    }

    void show() {
        cout << "name: " << _name << ", amount: " << _amount << ", price: " << _price << endl;
        _date.show();
    }

private :
    char _name[20];  // 静态分配内存
    int _amount;
    double _price;
    CDate _date;    // 成员对象

};

int main() {
    CGoods goods("Book", 100, 59.9, 1949, 12, 22);
    goods.show();
    return 0;
}

程序执行后的输出结果：

1
2
name: Book, amount: 100, price: 59.9
year: 1949, month: 12, day: 22

高频面试题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>

using namespace std;

class Test {

public:
    Test(int data = 10) : mb(data), ma(mb) {

    }

    void show() {
        cout << "ma: " << ma << ", mb: " << mb << endl;
    }

private:
    int ma;
    int mb;

};

int main() {
    Test test;
    test.show();
    return 0;
}

程序执行后的输出结果：

1
ma: -858993460, mb: 10

特别注意

类成员变量的初始化顺序和它们定义的顺序有关，和构造函数初始化列表中定义的先后顺序无关，更多关于构造函数初始化列表的使用教程请看 这里。

类模板与函数模板

函数模板的使用

在 C++ 中，与函数模板相关的专业术语（知识点）有以下几个：

  • 函数模板
  • 模板的实例化
  • 模板函数
  • 模板的类型参数
  • 模板的非类型参数
  • 模板的实参推演
  • 模板的特例化（专用化）
  • 非模板函数的重载关系

特别注意

  • 模板代码是不能在一个 .cpp 源文件中定义，然后在另一个 .cpp 源文件中使用的。
  • 模板代码在调用之前，一定要看到模板定义的地方，这样模板才能够进行正常的实例化，产生能够被编译器编译的代码。所以，模板代码一般都是写在 .h 头文件中的，然后在 .cpp 源文件中使用 #include 指令将头文件包含进来。
  • 另一种解决办法是，在调用模板函数之前，通过 template bool compare<int>(int, int) 告诉编译器，提前进行指定类型的模板实例化。

使用案例一

函数模板的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <iostream>
#include <cstring>

using namespace std;

// 定义一个模板参数列表
template<typename T>
// 定义一个函数模板
bool compare(T a, T b) {
    cout << "call compare(T a, T b)" << endl;
    return a > b;
}

// 针对 compare 函数模板，提供 const char* 类型的特例化版本
template<>
bool compare<const char *>(const char *a, const char *b) {
    cout << "call compare(const char *a, const char *b)" << endl;
    return strcmp(a, b);
}

// 普通函数（非模板函数）
bool compare(const char *a, const char *b) {
    cout << "call normal compare()" << endl;
    return strcmp(a, b);
}

/**
在函数调用点，编译器会使用用户指定的类型，从原函数模板实例化一份函数代码出来（称为模板函数），如下所示：

bool compare<int> (int a, int b) {

}

bool compare<double> (double a, double b) {

}
*/

int main() {
    // 函数的调用点
    compare<int>(10, 30);
    compare<double>(1.3, 4.5);

    // 函数模板的实参推演
    compare(20, 40);

    // 编译器优先将 compare 处理成普通函数，如果函数不存在，才会去找 compare 模板函数
    compare("abc", "efg");
    compare<const char *>("abc", "efg");

    return 0;
}

程序执行后的输出结果：

1
2
3
4
5
call compare(T a, T b)
call compare(T a, T b)
call compare(T a, T b)
call normal compare()
call compare(const char *a, const char *b)

使用案例二

模板的非类型参数使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>

using namespace std;

// 函数模板
// 使用模板的非类型参数（必须是整数类型，整数或者地址/引用都可以），非类型参数都是常量，只能使用，不能修改
template<typename T, int SIZE>
void sort(T *array) {
    // 冒泡排序
    for (int i = 0; i < SIZE - 1; i++) {
        for (int j = 0; j < SIZE - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                int tmp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = tmp;
            }
        }
    }
}

int main() {
    int array[] = {12, 4, 15, 3, 9, 23, 63};
    const int size = sizeof(array) / sizeof(array[0]);

    sort<int, size>(array);

    for (int item: array) {
        cout << item << " ";
    }
    cout << endl;

    return 0;
}

程序执行后的输出结果：

1
3 4 9 12 15 23 63

类模板的使用

使用案例一

类模板的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include <iostream>

using namespace std;

// 类模板
template<typename T>
// 顺序栈
class SeqStack {

public:

    // 建议构造和析构函数的名称不加 <T>，而且其他使用模板的地方都加上类型参数类列表，比如 <T>

    // 构造函数
    SeqStack(int size = 10) : _pstatck(new T[size]), _top(-1), _size(size) {

    }

    // 析构函数
    ~SeqStack() {
        if (_pstatck != nullptr) {
            delete[]_pstatck;
            _pstatck = nullptr;
        }
    };

    // 拷贝构造函数
    SeqStack(const SeqStack<T> &stack) : _top(stack._top), _size(stack._size) {
        // 实现深拷贝
        _pstatck = new T[_size];
        for (int i = 0; i < _top; i++) {
            _pstatck[i] = stack._pstatck[i];
        }
    }

    // 赋值运算符重载
    SeqStack<T> &operator=(const SeqStack<T> &stack) {
        if (this == stack) {
            return *this;
        }

        // 释放原来的内存空间
        if (_pstatck != nullptr) {
            delete[]_pstatck;
        }

        // 实现深拷贝
        _top = stack._top;
        _size = stack._size;
        _pstatck = new T[_size];
        for (int i = 0; i < _top; i++) {
            _pstatck[i] = stack._pstatck[i];
        }

        return *this;
    }

    // 入栈
    void push(const T &val) {
        if (full()) {
            resize();
        }
        _pstatck[++_top] = val;
    }

    // 弹栈
    void pop() {
        if (!empty()) {
            --_top;
        }
    }

    // 获取栈顶元素
    T top() const {
        if (empty()) {
            throw "stack is empty!";
        }
        return _pstatck[_top];
    }

    // 栈是否满了
    bool full() const {
        return _top == _size - 1;
    }

    // 栈是否为空
    bool empty() const {
        return _top == -1;
    }

private :
    T *_pstatck; // 动态开辟数组，存储顺序栈的元素
    int _top;    // 指向栈顶元素的位置
    int _size;   // 数组的总大小

    // 扩容操作
    void resize() {
        T *ptmp = new T[_size * 2];
        for (int i = 0; i < _top; i++) {
            ptmp[i] = _pstatck[i];
        }
        delete[]_pstatck;
        _pstatck = ptmp;
        _size *= 2;
    }

};

int main() {
    // 设置随机数种子
    srand(time(nullptr));

    // 类模板的选择性实例化
    // 实例化后的模板类 class SeqStack<int> { };
    SeqStack<int> stack;
    for (int i = 0; i < 20; i++) {
        stack.push(rand() % 100);
    }

    while (!stack.empty()) {
        cout << stack.top() << " ";
        stack.pop();
    }
    return 0;
}

程序执行后的输出结果：

1
6 68 25 5 53 1 20 71 3 7 0 99 2 74 78 99 92 30 24 40

使用案例二

类模板的默认类型参数使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 类模板（使用默认类型参数）
template<typename T=int>
// 顺序栈
class SeqStack {
    
    ......
    
}

int main() {
    // 使用默认类型参数
    SeqStack<> stack;

    return 0;
}

使用案例三

使用类模板实现向量容器（Vector）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
#include <iostream>

using namespace std;

// 类模板
template<typename T>
// 向量容器
class MyVector {

public:
    // 构造函数
    MyVector(int size = 10) {
        _first = new T[size];
        _last = _first;
        _end = _first + size;
    }

    // 析构函数
    ~MyVector() {
        if (_first != nullptr) {
            delete[] _first;
            _first = _last = _end = nullptr;
        }
    }

    // 拷贝构造函数
    MyVector(const MyVector<T> &v) {
        // 容器的总大小
        int size = v._end - v._first;
        // 有效元素的个数
        int length = v._last - v._first;
        // 深拷贝
        _first = new T[size];
        for (int i = 0; i < length; i++) {
            _first[i] = v._first[i];
        }
        _last = _first + length;
        _end = _first + size;
    }

    // 赋值运算符重载
    MyVector<T> &operator=(const MyVector<T> &v) {
        if (this == v) {
            return *this;
        }

        // 释放原来的内存空间
        if (_first != nullptr) {
            delete[] _first;
        }

        // 容器的总大小
        int size = v._end - v._first;
        // 有效元素的个数
        int length = v._last - v._first;
        // 深拷贝
        _first = new T[size];
        for (int i = 0; i < length; i++) {
            _first[i] = v._first[i];
        }
        _last = _first + length;
        _end = _first + size;

        return *this;
    }

    // 往容器尾部添加元素
    void push_back(const T &val) {
        if (full()) {
            resize();
        }
        *_last++ = val;
    }

    // 从容器尾部删除元素
    void pop_back() {
        if (!empty()) {
            --_last;
        }
    }

    // 返回容器尾部的元素
    T back() const {
        if (empty()) {
            throw "MyVector is empty!";
        }
        return *(_last - 1);
    }

    // 容器是否满了
    bool full() const {
        return _last == _end;
    }

    // 容器是否为空
    bool empty() const {
        return _first == _last;
    }

    // 返回有效元素的个数
    int size() const {
        return _last - _first;
    }

private:
    T *_first;  // 指向数组起始的位置
    T *_last;   // 指向数组中有效元素的后继位置
    T *_end;    // 指向数组空间的后继位置

    // 扩容操作
    void resize() {
        int size = _end - _first;
        T *_ptemp = new T[size * 2];

        for (int i = 0; i < size; i++) {
            _ptemp[i] = _first[i];
        }

        // 释放原来的内存空间
        delete[] _first;

        _first = _ptemp;
        _last = _first + size;
        _end = _first + size * 2;
    }
};

int main() {
    // 设置随机数种子
    srand(time(nullptr));

    MyVector<int> v;
    for (int i = 0; i < 20; i++) {
        int val = rand() % 100;
        v.push_back(val);
        cout << val << " ";
    }
    cout << endl;

    cout << "size: " << v.size() << endl;
    cout << "full: " << (v.full() ? "true" : " false") << endl;
    cout << "empty: " << (v.empty() ? "true" : " false") << endl;

    while (!v.empty()) {
        cout << v.back() << " ";
        v.pop_back();
    }

    return 0;
}

程序执行后的输出结果：

1
2
3
4
5
49 32 50 26 17 87 26 65 49 83 36 57 97 61 25 44 84 23 41 35 
size: 20
full: true
empty:  false
35 41 23 84 44 25 61 97 57 36 83 49 65 26 87 17 26 50 32 49

特别注意

  • 上述代码实现的 vector 容器，如果存放的是 Peson 类的对象，那么在容器初始化的时候，默认会调用 10 次 Peson 类的构造函数，因为在容器的构造函数中使用了 new 操作，比如 _first = new T[size]。
  • 上述代码实现的 vector 容器，如果存放的是 Peson 类的对象，当调用 pop_back() 函数来删除容器尾部的元素时，Person 对象所占用的内存空间并没有被释放，这存在内存泄漏问题。
  • 解决内存泄漏的方法可以参考 C++ STL 中的 vector 容器的实现，也就是使用空间配置器（allocator）来解决，空间配置器负责做四件事情，包括：内存开辟、内存释放、对象构造、对象析构。

使用空间分配器优化后的代码（重点知识）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
#include <iostream>
#include <cstring>

using namespace std;

// 类模板
template<typename T>
// 空间配置器（负责内存开辟、内存释放、对象构造、对象析构）
struct MyAllocator {

    // 数组的内存开辟
    T *allocate(size_t size) {
        return (T *) malloc(sizeof(T) * size);
    }

    // 数组的内存释放
    void deallocate(void *p) {
        free(p);
    }

    // 对象构造
    void construct(T *p, const T &val) {
        // 在指定的内存上构造对象（定位 new）
        new (p)T(val);
    }

    // 对象析构
    void destroy(T *p) {
        // ~T() 代表了 T 类型对象的析构函数
        p->~T();
    }

};

// 类模板
template<typename T, typename Alloc = MyAllocator<T>>
// 向量容器
class MyVector {

public:
    // 构造函数
    MyVector(int size = 10) {
        // 开辟数组的内存空间
        _first = _allocator.allocate(size);
        _last = _first;
        _end = _first + size;
    }

    // 析构函数（先析构容器内的有效元素，然后再释放 _first 指针指向的堆内存）
    ~MyVector() {
        // 析构容器内的有效元素
        for (T *p = _first; p != _last; p++) {
            _allocator.destroy(p);
        }

        // 释放堆上的数组内存
        _allocator.deallocate(_first);
        _first = _last = _end = nullptr;
    }

    // 拷贝构造函数
    MyVector(const MyVector<T> &v) {
        // 容器的总大小
        int size = v._end - v._first;
        // 有效元素的个数
        int length = v._last - v._first;

        // 开辟数组的内存空间
        _first = _allocator.allocate(size);

        // 在指定的内存空间中构造对象
        for (int i = 0; i < length; i++) {
            _allocator.construct(_first + i, v._first[i]);
        }
        _last = _first + length;
        _end = _first + size;
    }

    // 赋值运算符重载
    MyVector<T> &operator=(const MyVector<T> &v) {
        if (this == v) {
            return *this;
        }

        // 析构容器内的有效元素
        for (T *p = _first; p != _last; p++) {
            _allocator.destroy(p);
        }

        // 释放堆上的数组内存
        _allocator.deallocate(_first);

        // 容器的总大小
        int size = v._end - v._first;
        // 有效元素的个数
        int length = v._last - v._first;

        // 开辟数组的内存空间
        _first = _allocator.allocate(size);

        // 在指定的内存空间中构造对象
        for (int i = 0; i < length; i++) {
            _allocator.construct(_first + i, v._first[i]);
        }
        _last = _first + length;
        _end = _first + size;

        return *this;
    }

    // 往容器尾部添加元素
    void push_back(const T &val) {
        if (full()) {
            resize();
        }
        // 在指定的内存空间中构造对象
        _allocator.construct(_last, val);
        _last++;
    }

    // 从容器尾部删除元素（需要将对象的析构和内存释放分开处理）
    void pop_back() {
        if (!empty()) {
            _last--;
            // 在指定的内存空间中析构对象
            _allocator.destroy(_last);
        }
    }

    // 返回容器尾部的元素
    T back() const {
        if (empty()) {
            throw "MyVector is empty!";
        }
        return *(_last - 1);
    }

    // 容器是否满了
    bool full() const {
        return _last == _end;
    }

    // 容器是否为空
    bool empty() const {
        return _first == _last;
    }

    // 返回有效元素的个数
    int size() const {
        return _last - _first;
    }

private:
    T *_first;  // 指向数组起始的位置
    T *_last;   // 指向数组中有效元素的后继位置
    T *_end;    // 指向数组空间的后继位置
    Alloc _allocator;   // 定义容器空间配置器的对象

    // 扩容操作
    void resize() {
        int size = _end - _first;
        // 开辟数组的内存空间
        T *_ptemp = _allocator.allocate(size * 2);
        // 在指定的内存空间中构造对象
        for (int i = 0; i < size; i++) {
            _allocator.construct(_ptemp + i, _first[i]);
        }

        // 析构原来容器内的有效元素
        for (T *p = _first; p != _last; p++) {
            _allocator.destroy(p);
        }

        // 释放原来的数组内存
        _allocator.deallocate(_first);

        _first = _ptemp;
        _last = _first + size;
        _end = _first + size * 2;
    }
};

class Person {

public:
    Person() {
        cout << "call Person()" << endl;
    }

    Person(const Person &p) {
        cout << "call Person(const Person &p)" << endl;
    }

    ~Person() {
        cout << "call ~Person()" << endl;
    }

};

void test01() {
    cout << "============= test01() =============" << endl;

    MyVector<int> v;
    for (int i = 0; i < 20; i++) {
        int val = rand() % 100;
        v.push_back(val);
        cout << val << " ";
    }
    cout << endl;

    cout << "size: " << v.size() << endl;
    cout << "full: " << (v.full() ? "true" : " false") << endl;
    cout << "empty: " << (v.empty() ? "true" : " false") << endl;

    while (!v.empty()) {
        cout << v.back() << " ";
        v.pop_back();
    }
}

void test02() {
    cout << "\n\n============= test02() =============" << endl;

    Person p1, p2, p3;
    cout << "------------------------------------------" << endl;
    MyVector<Person> v;
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    cout << "------------------------------------------" << endl;
    v.pop_back();
    cout << "------------------------------------------" << endl;
}

int main() {
    // 设置随机数种子
    srand(time(nullptr));

    test01();
    test02();
    return 0;
}

程序执行后的输出结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
============= test01() =============
44 60 71 5 8 44 58 52 73 97 20 21 0 10 28 44 94 81 54 82 
size: 20
full: true
empty:  false
82 54 81 94 44 28 10 0 21 20 97 73 52 58 44 8 5 71 60 44 

============= test02() =============
call Person()
call Person()
call Person()
------------------------------------------
call Person(const Person &p)
call Person(const Person &p)
call Person(const Person &p)
------------------------------------------
call ~Person()
------------------------------------------
call ~Person()
call ~Person()
call ~Person()
call ~Person()
call ~Person()

模板特例化的使用

模板特例化的两种类型

在 C++ 中，模板特例化有两种类型，包括模板完全特例化（Full Specialization）和模板部分特例化（Partial Specialization），两者都是对模板（包括函数模板和类模板）进行特定处理的方式。它们的主要区别在于对模板参数的控制程度不一样。

  • 模板完全特例化

    • 完全特例化是指针对某个特定的模板参数组合，提供完全定制的实现。特例化版本不会使用泛型模板的代码，而是使用特化版本的实现。
    • 需要使用 template<> 语法，因为完全特例化没有泛型参数。
    • 针对特定类型提供完全不同的实现，和原始模板无关。

  • 模板部分特例化

    • 部分特例化是指保留部分模板参数的泛型性，仅对某些参数的特定情况进行特化。部分特例化仍然依赖于原始模板的框架，但可以对部分参数提供不同的实现。
    • 仍然使用 template<...> 语法，但部分参数被具体化，其他参数仍保持泛型性。
    • 允许对部分模板参数进行特化，而不影响其他参数。

模板完全特例化与模板部分特例化的对比总结

比较项模板完全特例化模板部分特例化
作用针对某个特定类型组合提供完整的实现仅对部分模板参数提供特化实现
泛型性没有泛型参数，完全具体化仍然保留部分泛型参数
语法template<> class Test<int> {...}template<typename T2> class Test<int, T2> {...}
影响范围仅适用于特定类型适用于一类特殊情况

为什么需要模板特例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <cstring>

using namespace std;

// 通用模板
template<typename T>
bool compare(T a, T b) {
    cout << "template compare" << endl;
    return a > b;
}

// 模板完全特例化（实现字符串比较）
template<>
bool compare<const char *>(const char *s1, const char *s2) {
    cout << "string template compare" << endl;
    return strcmp(s1, s2) > 0;
}

int main() {
    compare(10, 20);

    // 如果不使用模板特例化，这里默认只会简单比较字符串指针的地址，并不符合预期行为
    compare("aaa", "bbb");

    return 0;
}

程序运行输出的结果如下：

1
2
template compare
string template compare

模板完全特例化的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>

using namespace std;

// 通用模板
template<typename T>
class MyVector {

public:
    MyVector() {
        cout << "MyVector init" << endl;
    }

};

// 模板完全特例化
// 针对 char * 类型提供完全特例化版本
template<>
class MyVector<char *> {

public:
    MyVector() {
        cout << "MyVector<char *> init" << endl;
    }

};

int main() {
    MyVector<int> vec1;
    MyVector<char *> vec2;
    return 0;
}

程序运行输出的结果如下：

1
2
MyVector init
MyVector<char *> init

模板部分特例化的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>

using namespace std;

// 通用模板
template<typename T>
class MyVector {

public:
    MyVector() {
        cout << "MyVector init" << endl;
    }

};

// 模板部分特例化
// 针对指针类型提供部分特例化版本
template<typename Ty>
class MyVector<Ty *> {

public:
    MyVector() {
        cout << "MyVector<Ty *> init" << endl;
    }

};

// 模板部分特例化
// 针对函数（有返回值，有两个参数）类型提供部分特例化版本
template<typename R, typename A1, typename A2>
class MyVector<R(A1, A2)> {

public:
    MyVector() {
        cout << "MyVector<R(A1, A2)> init" << endl;
    }

};

// 模板部分特例化
// 针对函数指针（有返回值，有两个参数）类型提供部分特例化版本
template<typename R, typename A1, typename A2>
class MyVector<R(*)(A1, A2)> {

public:
    MyVector() {
        cout << "MyVector<R(*)(A1, A2) init" << endl;
    }

};

int main() {
    MyVector<int> vec1;
    MyVector<int *> vec3;
    MyVector<int(int, int)> vec4;
    MyVector<int (*)(int, int)> vec5;
    return 0;
}

程序运行输出的结果如下：

1
2
3
4
MyVector init
MyVector<Ty *> init
MyVector<R(A1, A2)> init
MyVector<R(*)(A1, A2) init

模板的实参推演

模板实参推演的概念

C++ 模板实参推演（Template Argument Deduction）是指在使用函数模板或类模板时，编译器根据提供的实参自动推导（而非手动指定）模板参数的过程。

模板实参推演的特性

  • 当调用函数模板时，编译器会根据传入的实参类型，推导出对应的模板参数。例如：
1
2
3
4
5
6
7
template <typename T>
void func(T x) { }

int main() {
    func(42);      // T 被推演为 int 类型，无需显式指定 func<int>(42)
    func(3.14);    // T 被推演为 double 类型，无需显式指定 func<double>(3.14)
}
  • 在 C++ 17 之前，类模板不支持类型自动推导，必须显式指定模板参数：
1
2
3
4
5
6
7
template <typename T>
class Box {
public:
    Box(T val) { }
};

Box<int> b(42);  // C++ 17 之前需要显式指定 Box<int>
  • 从 C++ 17 开始，类模板也支持类型自动推导：
1
2
3
4
5
6
7
template <typename T>
class Box {
public:
    Box(T val) { }
};

Box b(42);  // C++ 17 可以自动推导为 Box<int>

模板实参推演的理解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <iostream>

#if defined(__linux__)
    #define FUNCTION_SIGNATURE __PRETTY_FUNCTION__
#elif defined(_WIN32)
    #define FUNCTION_SIGNATURE __FUNCSIG__
#endif

using namespace std;

// 模板的实参推演

template<typename T>
void func(T a) {
    cout << "func => " << FUNCTION_SIGNATURE << endl;
}

template<typename R, typename A1, typename A2>
void func2(R (*)(A1, A2)) {
    cout << "func2 => " << FUNCTION_SIGNATURE << endl;
}

template<typename R, typename T, typename A1, typename A2>
void func3(R (T::*)(A1, A2)) {
    cout << "func3 => " << FUNCTION_SIGNATURE << endl;
}

int sum(int a, int b) {
    return a + b;
}

class Test {

public:
    int sum(int a, int b) {
        return a + b;
    }

};

int main() {
    func(10);
    func("aaa");
    func(sum);
    func2(sum);
    func3(&Test::sum);
    return 0;
}

在 Linux 平台，程序运行输出的结果如下：

1
2
3
4
5
func => void func(T) [with T = int]
func => void func(T) [with T = const char*]
func => void func(T) [with T = int (*)(int, int)]
func2 => void func2(R (*)(A1, A2)) [with R = int; A1 = int; A2 = int]
func3 => void func3(R (T::*)(A1, A2)) [with R = int; T = Test; A1 = int; A2 = int]

在 Windows 平台，程序运行输出的结果如下：

1
2
3
4
5
func => void __cdecl func<int>(int)
func => void __cdecl func<const char*>(const char *)
func => void __cdecl func<int(__cdecl *)(int,int)>(int (__cdecl *)(int,int))
func2 => void __cdecl func2<int,int,int>(int (__cdecl *)(int,int))
func3 => void __cdecl func3<int,class Test,int,int>(int (__cdecl Test::* )(int,int))

影响模板实参推演的因素

数组和指针
  • 数组实参会被退化为指针
1
2
3
4
5
6
7
8
9
template <typename T>
void func(T x) {

}

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    func(arr);  // T 被推演为 int*（数组退化）
}

若希望保持数组类型，可以使用模板参数 T&：

1
2
3
4
5
6
7
8
9
template <typename T>
void func(T& x) {

}

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    func(arr);  // T 被推演为 int[5]
}
传值和传引用
1
2
3
4
5
6
7
8
9
10
template <typename T>
void func(T& x) {

}

int main() {
    int a = 10;
    func(a);  // T 被推演为 int
    func(5);  // 错误写法：5 是右值，无法绑定到 T&（左值引用）
}

解决方案：使用右值引用（通用引用）T&& 适配左值和右值：

1
2
3
4
5
6
7
template <typename T>
void func(T&& x) {

}

func(10);  // T 推演为 int（右值）
func(a);   // T 推演为 int&（左值）
const 和 volatile 修饰符
1
2
3
4
5
6
7
8
9
template <typename T>
void func(T x) {

}

int main() {
    const int a = 10;
    func(a);  // T 推演为 int（const 被忽略）
}

若希望保留 const 或者 volatile 信息，可以使用模板参数 const T&：

1
2
3
4
5
6
7
8
9
template <typename T>
void func(const T& x) {

}

int main() {
    const int a = 10;
    func(a);  // T 推演为 int，参数类型保持 const int&
}