C++进阶教程：动态内存管理与智能指针

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

4
int main() {
5
    // 单个对象
6
    int *p = new int(42);        // 分配并初始化
7
    cout << "*p = " << *p << endl;  // 42
8
    delete p;                    // 释放内存（必须！）
9
    p = nullptr;                 // 悬垂指针置空
10

11
    // 数组
12
    int *arr = new int[5];
13
    for (int i = 0; i < 5; i++) arr[i] = i * 10;
14
    cout << "arr[3] = " << arr[3] << endl;  // 30
15
    delete[] arr;                // 数组用 delete[]
16

17
    // 对象
18
    string *s = new string("Hello");
19
    cout << *s << endl;
20
    delete s;
21
    return 0;
22
}

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

4
void leakExample() {
5
    int *p = new int(100);
6
    // 没有 delete p！函数结束指针技失，内存无法释放 → 内存泄漏
7
}
8

9
int main() {
10
    for (int i = 0; i < 1000; i++) {
11
        leakExample();   // 每次泄漏 4 字节
12
    }
13
    cout << "程序结束（已泄漏内存）" << endl;
14
    return 0;
15
}

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

4
int main() {
5
    int *p1 = new int(10);
6

7
    int *p2 = p1;        // 两个指针指向同一块内存
8
    delete p1;           // 释放
9
    // delete p2;        // 错误！双重释放 → 崩溃
10

11
    // *p2 = 20;         // 错误！p2 现在是悬垂指针（指向已释放内存）
12
    cout << "避免双重释放和悬垂指针访问" << endl;
13
    return 0;
14
}

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

4
// 手动管理：容易出错
5
class BadResource {
6
public:
7
    int *data;
8
    BadResource() : data(new int[100]) {}
9
    ~BadResource() { delete[] data; }   // 忘记写就泄漏
10
};
11

12
// RAII 思想已体现在之前的 String 类中：构造分配、析构释放
13
class SmartResource {
14
private:
15
    int *data;
16
public:
17
    SmartResource() : data(new int[100]) {
18
        cout << "获取资源" << endl;
19
    }
20
    ~SmartResource() {
21
        delete[] data;
22
        cout << "自动释放资源" << endl;
23
    }
24
};
25

26
int main() {
27
    {
28
        S
29
martResource r;   // 构造：获取资源
30
        cout << "使用资源..." << endl;
31
    }                       // 析构：自动释放（即使有异常也会释放）
32
    cout << "RAII 保证资源安全释放" << endl;
33
    return 0;
34
}

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

5
class Resource {
6
public:
7
    Resource() { cout << "资源创建" << endl; }
8
    ~Resource() { cout << "资源释放" << endl; }
9
    void work() { cout << "工作中..." << endl; }
10
};
11

12
int main() {
13
    // 方式一：直接构造
14
    unique_ptr<Resource> p1(new Resource());
15

16
    // 方式二：make_unique（推荐，C++14）
17
    auto p2 = make_unique<Resource>();
18

19
    // 不能拷贝
20
    // unique_ptr<Resource> p3 = p1;   // 错误！
21

22
    // 转移所有权
23
    unique_ptr<Resource> p3 = move(p1);
24
    // p1 �
25
��在是空指针
26

27
    p3->work();
28
    // 离开作用域自动释放
29
    return 0;
30
}

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

5
class Resource {
6
public:
7
    int id;
8
    Resource(int i) : id(i) { cout << "创建资源 " << id << endl; }
9
    ~Resource() { cout << "释放资源 " << id << endl; }
10
};
11

12
int main() {
13
    // make_
14
shared：一次分配对象和计数块（推荐）
15
    shared_ptr<Resource> p1 = make_shared<Resource>(1);
16

17
    cout << "p1 引用计数: " << p1.use_count() << endl;  // 1
18

19
    {
20
        shared_ptr<Resource> p2 = p1;   // 拷贝：计数 +1
21
        shared_ptr<Resource> p3 = p1;   // 拷贝：计数 +1
22
        cout << "计数: " << p1.use_count() << endl;      // 3
23
        cout << "p2->id = " << p2->id << endl;          // 1
24
    }   // p2, p3 销毁，计数 -2
25

26
    cout << "计数: " << p1.use_count() << endl;  // 1
27
    // p1 销毁时计数归零，释放资源
28
    return 0;
29
}

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

5
class B;   // 前向声明
6

7
class A {
8
public:
9
    shared_ptr<B> b_ptr;
10
    ~A() { cout << "A 析构" << endl; }
11
};
12

13
class B {
14
public:
15
    // 若这里用 shared_ptr<A>，则 A 和 B 互相持有 → 循环引用，都不释放
16
    weak_ptr<A> a_ptr;   // 用 weak_ptr 打破循环
17
    ~B() { cout << "B 析构" << endl; }
18
};
19

20
int main() {
21
    shared_ptr<A> a = make_shared<A>()
22
;
23
    shared_ptr<B> b = make_shared<B>();
24
    a->b_ptr = b;
25
    b->a_ptr = a;    // weak_ptr 不增加计数
26

27
    cout << "a 计数: " << a.use_count() << endl;  // 1（b 持有的是 weak）
28
    cout << "b 计数: " << b.use_count() << endl;  // 2（a 持有 shared）
29

30
    // 用 weak_ptr 访问需要 lock()
31
    if (auto sp = b->a_ptr.lock()) {
32
        cout << "通过 weak_ptr 访问 A 成功" << endl;
33
    }
34
    // 程序结束：a 和 b 都能正常析构
35
    return 0;
36
}

1
#include <iostream>
2
#include <memory>
3
#include <vector>
4
using namespace std;
5

6
class Shape {
7
public:
8
    virtual double area() const = 0;
9
    virtual void info() const = 0;
10
    virtual ~Shape() {}
11
};
12

13
class Circle : public Shape {
14
    doubl
15
e r;
16
public:
17
    Circle(double radius) : r(radius) {}
18
    double area() const override { return 3.14159 * r * r; }
19
    void info() const override { cout << "圆面积: " << area() << endl; }
20
};
21

22
class Rectangle : public Shape {
23
    double w, h;
24
public:
25
    Rectangle(double a, double b) : w(a), h(b) {}
26
    double area() const override { return w * h; }
27
    void info() const override { cout << "矩形面积: " << area() << endl; }
28
};
29

30
int main() {
31
    // 容器存储智能指针：自动管理生命周期，无需手动 delete
32
    vector<unique_ptr<Shape>> shapes;
33
    shapes.push_back(make_uniqu
34
e<Circle>(3));
35
    shapes.push_back(make_unique<Rectangle>(4, 5));
36

37
    double total = 0;
38
    for (const auto &s : shapes) {
39
        s->info();
40
        total += s->area();
41
    }
42
    cout << "总面积: " << total << endl;
43
    // 离开作用域 vector 析构，unique_ptr 自动释放所有 Shape
44
    return 0;
45
}

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

5
class Logger {
6
public:
7
    virtual void log(const string &msg) const = 0;
8
    virtual ~Logger() {}
9
};
10

11
class ConsoleLogger : public Logger {
12
public:
13
    void log(const string
14
&msg) const override {
15
        cout << "[控制台] " << msg << endl;
16
    }
17
};
18

19
class FileLogger : public Logger {
20
public:
21
    void log(const string &msg) const override {
22
        cout << "[文件] " << msg << endl;
23
    }
24
};
25

26
// 工厂函数：返回 unique_ptr，所有权转移给调用者
27
unique_ptr<Logger> createLogger(const string &type) {
28
    if (type == "console") {
29
        return make_unique<ConsoleLogger>();
30
    } else {
31
        return make_unique<FileLogger>();
32
    }
33
}
34

35
int main() {
36
    auto logger = createLogger("console");
37
    logger->log("系统启动");
38

39
    logger = createLogger(
40
"file");   // 旧对象自动释放
41
    logger->log("切换到文件日志");
42
    return 0;
43
}

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

5
class Widget {
6
public:
7
    void show() { cout << "Widget" << endl; }
8
};
9

10
void process(shared_ptr<Widget> p) {
11
    cout << "处理中，计数: " << p.use_count() << endl;
12
}
13

14
int main() {
15
    // 规范 1：用 make_shared 而非 new
16
    shared_ptr<Widget> w = make_shared<Widget>();
17

18
    // 规范 2：传参用值传递（拷贝）或用 const&
19
    process(w);
20

21
    // 规范 3：不要混用裸指针和�
22
�能指针
23
    // Widget *raw = w.get();  // get() 只读不拥有
24

25
    // 规范 4：不要用裸指针创建多个 shared_ptr
26
    // Widget *rw = new Widget();
27
    // shared_ptr<Widget> s1(rw);
28
    // shared_ptr<Widget> s2(rw);   // 错误！双重释放
29

30
    w->show();
31
    return 0;
32
}

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

5
struct Node {
6
    int data;
7
    unique_ptr<Node> next;   // 每个节点独占下一个节点
8

9
    Node(int v) : data(v) {}
10
};
11

12
class Linke
13
dList {
14
private:
15
    unique_ptr<Node> head;
16

17
public:
18
    // 头插法
19
    void pushFront(int value) {
20
        auto newNode = make_unique<Node>(value);
21
        newNode->next = move(head);    // 转移旧头节点
22
        head = move(newNode);
23
    }
24

25
    void print() const {
26
        Node *cur = head.get();
27
        while (cur) {
28
            cout << cur->data << " ";
29
            cur = cur->next.get();
30
        }
31
        cout << endl;
32
    }
33

34
    // 析构：head 释放时自动递归释放整个链表
35
};
36

37
int main() {
38
    LinkedList list;
39
    list.pushFront(30);
40
    list.pushFront(20);
41
    list.push
42
Front(10);
43

44
    list.print();   // 10 20 30
45
    // list 析构时整个链表自动释放，无内存泄漏
46
    cout << "链表已自动释放" << endl;
47
    return 0;
48
}