第三节 · 瓶子工厂 · 动态数组

手动管理内存容易出错。C++11 引入了智能指针，它们在不再需要时自动释放内存，大大降低了内存泄漏的风险。

---

unique_ptr - 独占所有权

unique_ptr 独占它所指向的对象，不能复制，只能移动。

#include <memory>
using namespace std;

int main()
{
    // 创建 unique_ptr
    unique_ptr<int> p1(new int(42));
    
    // C++14 推荐方式
    auto p2 = make_unique<int>(42);
    
    cout << *p2 << endl;  // 42
    
    // unique_ptr<int> p3 = p2;  // 错误！不能复制
    unique_ptr<int> p3 = move(p2);  // 可以移动
    
    // 此时 p2 为空
    if (!p2) cout << "p2 is null" << endl;
    
    return 0;
}  // p1, p3 自动释放

---

unique_ptr 与数组

// 管理数组
auto arr = make_unique<int[]>(10);

for (int i = 0; i < 10; ++i)
{
    arr[i] = i * i;
}
// 自动调用 delete[]

---

shared_ptr - 共享所有权

shared_ptr 允许多个指针指向同一对象，使用引用计数管理生命周期。

#include <memory>
using namespace std;

int main()
{
    auto p1 = make_shared<int>(42);
    cout << "count: " << p1.use_count() << endl;  // 1
    
    {
        auto p2 = p1;  // 可以复制
        cout << "count: " << p1.use_count() << endl;  // 2
        cout << "count: " << p2.use_count() << endl;  // 2
    }  // p2 销毁，引用计数减 1
    
    cout << "count: " << p1.use_count() << endl;  // 1
    
    return 0;
}  // 引用计数归零，释放内存

---

weak_ptr - 弱引用

weak_ptr 不增加引用计数，用于解决循环引用问题。

#include <memory>
using namespace std;

struct Node
{
    int value;
    // shared_ptr<Node> next;  // 可能造成循环引用
    weak_ptr<Node> next;       // 用 weak_ptr 避免
    
    ~Node() { cout << "Node " << value << " destroyed" << endl; }
};

int main()
{
    auto n1 = make_shared<Node>();
    auto n2 = make_shared<Node>();
    
    n1->value = 1;
    n2->value = 2;
    
    n1->next = n2;
    n2->next = n1;  // 如果用 shared_ptr，这里会造成循环引用
    
    // 使用 weak_ptr 前需要转换为 shared_ptr
    if (auto p = n1->next.lock())
    {
        cout << "next value: " << p->value << endl;
    }
    
    return 0;
}  // 正常释放

---

选择指南

场景	选择
独占所有权	unique_ptr
共享所有权	shared_ptr
打破循环引用	weak_ptr
性能敏感	优先 unique_ptr

---

智能指针与函数

// 传递智能指针
void process(unique_ptr<int> p)
{
    cout << *p << endl;
}  // p 在这里销毁

void processRef(const unique_ptr<int>& p)
{
    cout << *p << endl;
}  // p 不会销毁

int main()
{
    auto p = make_unique<int>(42);
    
    // process(p);  // 错误！不能复制
    // process(move(p));  // 可以，但之后 p 为空
    
    processRef(p);  // 推荐：传引用
    cout << *p << endl;  // p 仍然有效
    
    return 0;
}

---

智能指针与工厂模式

class Shape
{
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape
{
public:
    void draw() override { cout << "Drawing circle" << endl; }
};

class Rectangle : public Shape
{
public:
    void draw() override { cout << "Drawing rectangle" << endl; }
};

// 工厂函数
unique_ptr<Shape> createShape(const string& type)
{
    if (type == "circle")
        return make_unique<Circle>();
    else if (type == "rectangle")
        return make_unique<Rectangle>();
    return nullptr;
}

int main()
{
    auto shape = createShape("circle");
    if (shape) shape->draw();
    
    return 0;
}

---

自定义删除器

// 用于管理 C 风格资源
auto fileDeleter = [](FILE* f)
{
    if (f) fclose(f);
    cout << "File closed" << endl;
};

int main()
{
    unique_ptr<FILE, decltype(fileDeleter)> file(
        fopen("test.txt", "w"), fileDeleter);
    
    if (file)
    {
        fprintf(file.get(), "Hello, World!");
    }
    
    return 0;
}  // 自动调用 fclose

---

常见陷阱

// 1. 不要用同一个原始指针创建多个智能指针
int* raw = new int(42);
shared_ptr<int> p1(raw);
// shared_ptr<int> p2(raw);  // 错误！双重释放

// 2. 不要返回局部对象的智能指针
// 这是安全的，因为返回的是对象本身
shared_ptr<int> safe()
{
    return make_shared<int>(42);
}

// 3. 用 make_shared/make_unique，不要直接 new
auto p = make_shared<int>(42);  // 推荐
// shared_ptr<int> p(new int(42));  // 不推荐

---

习题

• 解释 unique_ptr 和 shared_ptr 的区别和使用场景。

• 什么是循环引用？如何解决？

• 实现一个使用智能指针的链表。