C++进阶教程：类与对象深入

发布时间：2026-08-28 18:11:20

🕒 阅读时间：18 分钟📝 字数：2476👀 阅读量：Loading...

本文是 C++ 系列教程的第 6 篇。上一篇初探了类的基本语法，本篇深入类与对象：构造函数与析构顺序、初始化列表、拷贝构造与拷贝赋值、深拷贝与浅拷贝、static 成员、const 成员函数、this 指针与友元。

一、构造函数深入

1.1 构造函数的种类

1
#include <iostream>
2
using namespace std;
3

4
class Person {
5
private:
6
    string name;
7
    int age;
8

9
public:
10
    // 1. 默认构造（无参）
11
    Person() : name("未命名"), age(0) {
12
        cout << "默认构造" << endl;
13
    }
14

15
    // 2. 带参构造
16
    Person(string n, int a) : name(n), age(a) {
17
        cout << "带参构造: " << name << endl;
18
    }
19

20
    // 3. 拷贝构造（重要！）
21
    Person(const Person &other) : name(other.name), age(other.age) {
22
        cout << "拷贝构造: 复制 " << other.name << endl;
23
    }
24

25
    void show() const {
26
        cout << name << " " << age << "岁" << endl;
27
    }
28
};
29

30
int main() {
31
    Person p1;                    // 默认构造
32
    Person p2("张三", 25);         // 带参构造
33
    Person p3 = p2;               // 拷贝构造
34
    Person p4(p2);                // 拷贝构造（等价写法）
35

36
    p1.show();
37
    p2.show();
38
    p3.show();
39
    return 0;
40
}

1.2 初始化列表（推荐）

1
#include <iostream>
2
using namespace std;
3

4
class Student {
5
private:
6
    const int id;        // const 成员必须在初始化列表初始化
7
    string name;
8

9
public:
10
    // 初始化列表语法：在 : 后按声明顺序初始化
11
    Student(int i, string n) : id(i), name(n) {
12
        // 函数体（可为空）
13
    }
14

15
    void show() const {
16
        cout << "学号 " << id << " " << name << endl;
17
    }
18
};
19

20
int main() {
21
    Student s(1001, "李四");
22
    s.show();   // 学号 1001 李四
23
    return 0;
24
}

初始化列表 vs 赋值：const 成员和引用成员只能在初始化列表初始化；初始化列表更高效（直接构造而非先默认构造再赋值）。

1.3 构造与析枔的顺序

1
#include <iostream>
2
using namespace std;
3

4
class A {
5
public:
6
    A() { cout << "A 构造" << endl; }
7
    ~A() { cout << "A 析构" << endl; }
8
};
9

10
class B : public A {   // 继承 A（第 8 篇详解）
11
public:
12
    B() { cout << "B 构造" << endl; }
13
    ~B() { cout << "B 析构" << endl; }
14
};
15

16
int main() {
17
    cout << "创建 B 对象:" << endl;
18
    B b;    // ��基类构造，再派生类构造
19
    cout << "销毁 B 对象:" << endl;
20
    // 先派生类析构，再基类析构
21
    return 0;
22
}

输出顺序：

1
创建 B 对象:
2
A 构造
3
B 构造
4
销毁 B 对象:
5
B 析构
6
A 析构

规则：构造顺序 = 基类 → 成员 → 自身；析构顺序完全相反。

二、深拷贝与浅拷贝

2.1 浅拷贝的灾难（悬垂指针）

1
#include <iostream>
2
#include <cstring>
3
using namespace std;
4

5
class StringBad {
6
private:
7
    char *str;      // 动态分配的内存
8
public:
9
    StringBad(const char *s) {
10
        str = new char[strlen(s) + 1];
11
        strcpy(str, s);
12
    }
13

14
    // 默认拷贝构造：逐字节复制（浅拷贝）！
15
    // 两个对象共享同一块内存
16

17
    ~StringBad() {
18
        delete[] str;   // 两个对象都 delete 同一内存 → 双重释放崩溃
19
    }
20

21
    void show() const { cout << str << endl; }
22
};
23

24
int main() {
25
    StringBad s1("Hello");
26
    StringBad s2 = s1;   // 浅拷贝：s1.str 和 s2.str 指向同一内存
27
    // 程序结束：s2 先析构 delete[]，s1 再析构 delete[] 同一地址 → 崩溃！
28
    cout << "程序将在此后崩溃（浅拷贝问题）" << endl;
29
    return 0;
30
}

2.2 深拷贝（正确做法）

1
#include <iostream>
2
#include <cstring>
3
using namespace std;
4

5
class String {
6
private:
7
    char *str;
8

9
public:
10
    // 构造
11
    String(const char *s = "") {
12
        str = new char[strlen(s) + 1];
13
        strcpy(str, s);
14
    }
15

16
    // 拷贝构造（深拷贝：分配新内存，复制内容）
17
    String(const String &other) {
18
        str = new char[strlen(other.str) + 1];
19
        strcpy(str, other.str);
20
        cout << "深拷贝构造" << endl;
21
    }
22

23
    // 拷贝赋值运算符（深拷贝）
24
    String &operator=(const String &other) {
25
        if (this == &other) return *this;   // 自赋值检查
26
        delete[] str;                        // 释放旧内存
27
        str = new char[strlen(other.str) + 1];
28
        strcpy(str, other.str);
29
        cout << "深拷贝赋值" << endl;
30
        return *this;
31
    }
32

33
    // 析构
34
    ~String() {
35
        delete[] str;
36
    }
37

38
    void show() const { cout << str << endl; }
39
};
40

41
int main() {
42
    String s1("Hello");
43
    String s2 = s1;    // 深拷贝构造：各自独立内存
44
    String s3("World");
45
    s2 = s3;           // 深拷贝赋值
46

47
    s1.show();  // Hello
48
    s2.show();  // World
49
    s3.show();  // World
50
    // 各自独立析构，无崩溃
51
    cout << "深拷贝程序正常结束" << endl;
52
    return 0;
53
}

2.3 三法则（Rule of Three）

如果类需要自定义析构函数，则几乎总需要自定义：

拷贝构造函数
拷贝赋值运算符

因为默认实现都是浅拷贝，与自定义析构（释放资源）矛盾。

三、static 成员

3.1 静态成员变量

1
#include <iostream>
2
using namespace std;
3

4
class Counter {
5
private:
6
    static int count;   // 静态成员：所有对象共享
7

8
public:
9
    Counter() { count++; }
10
    ~Counter() { count--; }
11

12
    static int getCount() { return count; }   // 静态成员函数
13
};
14

15
// 静态成员必须在类外定义（分配存储）
16
int Counter::count = 0;
17

18
int main() {
19
    cout << "初始: " << Counter::getCount() << endl;  // 0
20
    Counter c1;
21
    Counter c2;
22
    {
23
        Counter c3;
24
        cout << "现在: " << Counter::getCount() << endl;  // 3
25
    }   // c3 析构
26
    cout << "之后: " << Counter::getCount() << endl;      // 2
27
    return 0;
28
}

3.2 静态成员函数特性

1
#include <iostream>
2
using namespace std;
3

4
class MathUtils {
5
public:
6
    // 静态成员函数：不依赖对象，无 this 指针
7
    static int max(int a, int b) { return a > b ? a : b; }
8
    static int square(int x) { return x * x; }
9
};
10

11
int main() {
12
    // 通过类名直接调用
13
    cout << MathUtils::max(3, 7) << endl;     // 7
14
    cout << MathUtils::square(5) << endl;     // 25
15
    return 0;
16
}

注意：静态成员函数不能访问非静态成员（没有 this 指针）。

四、const 成员函数

1
#include <iostream>
2
#include <string>
3
using namespace std;
4

5
class Account {
6
private:
7
    string owner;
8
    double balance;
9

10
public:
11
    Account(string n, double b) : owner(n), balance(b) {}
12

13
    // const 成员函数：承诺不修改对象状态
14
    void show() const {
15
        cout << owner << " 余额 " << balance << endl;
16
        // balance = 0;   // 错误！const 成员函数不能修改
17
    }
18

19
    // 非 const 成员函数：可修改
20
    void deposit(double amount) {
21
        balance += amount;
22
    }
23

24
    // 可以同时有 const 和非 const 版本（重载）
25
    void info() const {
26
        cout << "[只读] " << owner << endl;
27
    }
28
    void info() {
29
        cout << "[可写] " << owner << endl;
30

31
}
32
};
33

34
void printAccount(const Account &acc) {
35
    // 参数是 const 引用，只能调用 const 成员函数
36
    acc.show();
37
    // acc.deposit(100);  // 错误！
38
}
39

40
int main() {
41
    Account a("小明", 100);
42
    printAccount(a);   // const 引用调用
43
    a.deposit(50);     // 非 const 对象可调用非 const 方法
44
    a.show();
45
    return 0;
46
}

五、this 指针

1
#include <iostream>
2
#include <string>
3
using namespace std;
4

5
class Employee {
6
private:
7
    string name;
8

9
public:
10
    Employee(string name) {
11
        // this 指针：指向当前对象的指针
12
        this->name = name;    // 解决参数与成员同名
13
    }
14

15
    // 返回自身引用（链式调用）
16
    Employee &setName(string name) {
17
        this->name = name;
18
        return *this;         // 返回解引用的 this
19
    }
20

21
    void show() const {
22
        cout << this->name << endl;   // this-> 可省略
23
    }
24
};
25

26
int main() {
27
    Employee e("张三");
28
    e.show();
29

30
    // 链式调用
31
    e.setName("李四").setName("王五");
32
    e.show();   // 王五
33
    return 0;
34
}

六、友元

6.1 友元函数

1
#include <iostream>
2
using namespace std;
3

4
class Box {
5
private:
6
    double width;
7
    double height;
8

9
public:
10
    Box(double w, double h) : width(w), height(h) {}
11

12
    // 声明友元函数：可以访问私有成员
13
    friend double getArea(const Box &b);
14
    friend Box operator+(const Box &a, const Box &b);
15
};
16

17
// 友元函数实现（不是成员函数）
18
double getArea(const Box &b) {
19
    return b.width * b.height;   // 访问私有成员
20
}
21

22
Box operator+(const Box &a, const Box &b) {
23
    return Box(a.width + b.width, a.height + b.height);
24
}
25

26
int main() {
27
    Box b1(3, 4), b2(2, 5);
28
    cout << "b1 面积: " << getArea(b1) << endl;   // 12
29
    Box sum = b1 + b2;
30
    cout << "合并面积: " << getArea(sum) << endl;  // 45
31
    return 0;
32
}

6.2 友元类

1
#include <iostream>
2
using namespace std;
3

4
class Secret {
5
private:
6
    int code;
7

8
public:
9
    Secret(int c) : code(c) {}
10
    friend class Decoder;   // Decoder 可以访问 Secret 私有成员
11
};
12

13
class Decoder {
14
public:
15
    void reveal(const Secret &s) {
16
        cout << "解密密码: " << s.code << endl;   // 访问私有
17
    }
18
};
19

20
int main() {
21
    Secret s(9527);
22
    Decoder d;
23
    d.reveal(s);   // 解密密码: 9527
24
    return 0;
25
}

使用原则：友元破坏封装，应谨慎使用（通常只在运算符重载等必要场景）。

七、实战：完整 String 类

综合本篇知识，实现完整的动态字符串类：

1
#include <iostream>
2
#include <cstring>
3
using namespace std;
4

5
class MyString {
6
private:
7
    char *data;
8
    int length;
9
    static int count;   // 统计创建了多少个
10

11
public:
12
    // 构造
13
    MyString(const char *s = "") {
14
        length = strlen(s);
15
        data = new char[length + 1];
16
        strcpy(data, s);
17
        count++;
18
        cout << "构造: " << data << endl;
19
    }
20

21
    // 深拷贝构造
22
    MyString(const MyString &other) {
23
        length = other.length;
24
        data = new char[length + 1];
25
        strcpy(data, other.data);
26
        count++;
27
        cout << "拷贝: " << data << endl;
28
    }
29

30
    // 深拷贝赋值
31
    MyString &operator=(const MyString &other) {
32
        if (this == &other) return *this;
33
        delete[] data;
34
        length = other.length;
35
        data = new char[length + 1];
36
        strcpy(data, other.data);
37
        cout << "赋值: " << data << endl;
38
        return *this;
39
    }
40

41
    // 拼接运算符重载
42
    MyString operator+(const MyString &other) const {
43
        char *temp = new char[length + other.length + 1];
44
        strcpy(temp, data);
45
        strcat(temp, other.data);
46
        MyString result(temp);
47
        delete[] temp;
48
        return result;
49
    }
50

51
    // 比较运算符
52
    bool operator==(const MyString &other) const {
53
        return strcmp(data, other.data) == 0;
54
    }
55

56
    // 析构
57
    ~MyString() {
58
        cout << "析构: " << data << endl;
59
        delete[] data;
60
        count--;
61
    }
62

63
    void show() const { cout << data << endl; }
64
    static int getCount() { return count; }
65
};
66

67
int MyString::count = 0;
68

69
int main() {
70
    MyString s1("Hello");
71
    MyString s2(" C++");
72
    MyString s3 = s1;          // 拷贝构造
73
    MyString s4 = s1 + s2;     // 拼接
74
    s3 = s4;                   // 拷贝赋值
75

76
    s4.show();                 // Hello C++
77
    cout << (s1 == MyString("Hello")) << endl;   // 1
78
    cout << "存活对象数: " << MyString::getCount() << endl;
79
    return 0;
80
}

总结

本篇深入讲解了构造函数的种类与初始化列表、构造析构顺序、深拷贝与浅拷贝的区别及三法则、static 成员、const 成员函数、this 指针和友元，并用完整 String 类串联实战。重点掌握：深拷贝防止双重释放、初始化列表的用法、static 与 const 的语法、this 指针的作用。

下一篇将讲解运算符重载与类型转换，敬请期待！