如何编写一个遵循“三/五/零之法则”的C++类来管理内存

浅瑶吖_7898

发布时间：2025-09-02 08:22:01

997人浏览过

来源于php中文网

原创

遵循“三/五/零法则”确保C++类正确管理资源：无需手动管理资源时遵循零法则，编译器自动生成默认函数；需管理资源时显式定义析构函数、拷贝构造、拷贝赋值、移动构造和移动赋值函数，防止内存泄漏、悬挂指针和双重释放；使用智能指针如std::unique_ptr和std::shared_ptr可自动管理资源，结合移动语义避免不必要的拷贝，提升性能。

如何编写一个遵循“三/五/零之法则”的c++类来管理内存

编写遵循“三/五/零法则”的 C++ 类，关键在于明确类的资源管理职责。如果类需要管理资源（如动态分配的内存），就需要遵循“三/五法则”；如果不需要，就遵循“零法则”。

解决方案

零法则（Rule of Zero）：

最简单的情况。如果你的类不需要显式管理任何资源（例如，它只包含

int

、

double

、

std::string

等成员，这些成员本身负责它们的资源管理），那么你不需要定义析构函数、拷贝构造函数或拷贝赋值运算符。编译器会自动生成它们，并且通常是正确的。

#include <string>

class Person {
public:
    Person(std::string name, int age) : name_(name), age_(age) {}

private:
    std::string name_;
    int age_;
}; // 编译器会自动生成析构函数、拷贝构造函数和拷贝赋值运算符

三/五法则（Rule of Three/Five）：

立即学习“C++免费学习笔记（深入）”；

如果你的类需要管理资源，比如动态分配内存，那么你需要显式地定义析构函数、拷贝构造函数和拷贝赋值运算符（这是“三法则”）。 C++11 引入了移动构造函数和移动赋值运算符，因此“三法则”扩展为“五法则”。

考虑一个简单的字符串类：

#include <cstring> // 包含 strlen, strcpy, delete[]

class MyString {
public:
    // 构造函数
    MyString(const char* str = nullptr) {
        if (str) {
            size_ = std::strlen(str);
            data_ = new char[size_ + 1];
            std::strcpy(data_, str);
        } else {
            size_ = 0;
            data_ = new char[1];
            data_[0] = '\0';
        }
    }

    // 析构函数
    ~MyString() {
        delete[] data_;
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        size_ = other.size_;
        data_ = new char[size_ + 1];
        std::strcpy(data_, other.data_);
    }

    // 拷贝赋值运算符
    MyString& operator=(const MyString& other) {
        if (this != &other) { // 防止自赋值
            delete[] data_;   // 释放旧资源
            size_ = other.size_;
            data_ = new char[size_ + 1];
            std::strcpy(data_, other.data_);
        }
        return *this;
    }

    // 移动构造函数 (C++11)
    MyString(MyString&& other) noexcept : size_(other.size_), data_(other.data_) {
        other.size_ = 0;
        other.data_ = nullptr;
    }

    // 移动赋值运算符 (C++11)
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = other.data_;
            other.size_ = 0;
            other.data_ = nullptr;
        }
        return *this;
    }

    const char* c_str() const { return data_; }

private:
    size_t size_;
    char* data_;
};

解释：

构造函数： 分配内存并复制字符串。
析构函数： 释放分配的内存。
拷贝构造函数： 创建一个新对象，并从另一个对象复制数据（深拷贝）。
拷贝赋值运算符： 避免自赋值，释放当前对象的内存，然后从另一个对象复制数据（深拷贝）。
移动构造函数： “窃取”另一个对象的资源，并将另一个对象置于有效但未定义的状态。
```
noexcept
```
说明符表示这个操作不会抛出异常，这对于移动操作非常重要。
移动赋值运算符： 类似于移动构造函数，但需要先释放当前对象的资源。

副标题1

为什么需要遵循“三/五/零法则”？不遵循会有什么问题？

不遵循“三/五/零法则”会导致各种资源管理问题，最常见的是内存泄漏和悬挂指针。

内存泄漏： 如果你分配了内存但没有在析构函数中释放它，那么每次创建和销毁对象时都会泄漏内存。随着时间的推移，这会导致程序耗尽所有可用内存并崩溃。
悬挂指针： 如果你复制了一个对象，但两个对象都指向同一块内存，那么当其中一个对象被销毁时，另一个对象将持有一个指向已释放内存的指针。访问这个指针会导致未定义的行为，通常是程序崩溃。
双重释放： 如果你浅拷贝一个对象，然后销毁这两个对象，析构函数会被调用两次，试图释放同一块内存两次，这也会导致崩溃。
性能问题： 默认的拷贝构造函数和拷贝赋值运算符可能会执行不必要的拷贝操作，尤其是在处理大型对象时。移动语义可以避免这些拷贝操作，提高性能。

副标题2

如何使用智能指针简化资源管理，并避免手动管理内存？

智能指针（如

std::unique_ptr

、

std::shared_ptr

和

std::weak_ptr

）可以自动管理动态分配的内存，从而避免手动管理内存的需要。它们是RAII（Resource Acquisition Is Initialization）原则的体现，即在对象构造时获取资源，在对象销毁时释放资源。

C++ 算法竞赛自动化测试数据生成与校验框架

根据原题生成新题面、验证器及完整测试数据，自动套用 testlib 模板，用于用户要求生成测试数据时。

下载

std::unique_ptr

：用于独占所有权的场景。一个

std::unique_ptr

只能指向一个对象，并且当

std::unique_ptr

被销毁时，它指向的对象也会被销毁。

#include <memory>

class MyClass {
public:
    MyClass() {
        data_ = new int[10];
    }
    ~MyClass() {
        delete[] data_;
    }
private:
    int* data_;
};

int main() {
    std::unique_ptr<MyClass> ptr(new MyClass()); // 使用 unique_ptr 管理 MyClass 对象
    // 当 ptr 超出作用域时，MyClass 对象会被自动销毁，data_ 也会被释放
    return 0;
}

使用

std::unique_ptr

后，你不需要显式地定义析构函数、拷贝构造函数和拷贝赋值运算符，因为

std::unique_ptr

已经为你处理了资源管理。

unique_ptr

不支持拷贝，只支持移动，这符合独占所有权的语义。

```
std::shared_ptr
```
：用于共享所有权的场景。多个
```
std::shared_ptr
```
可以指向同一个对象，并且只有当所有
```
std::shared_ptr
```
都被销毁时，该对象才会被销毁。
```
shared_ptr
```
使用引用计数来跟踪有多少个指针指向同一个对象。
```
#include <memory>

int main() {
    std::shared_ptr<int> ptr1(new int(10));
    std::shared_ptr<int> ptr2 = ptr1; // ptr1 和 ptr2 共享同一个 int 对象

    // 当 ptr1 和 ptr2 都超出作用域时，int 对象才会被销毁
    return 0;
}
```
使用
```
std::shared_ptr
```
可以简化资源管理，但也需要注意循环引用的问题，循环引用会导致对象永远不会被销毁。可以使用
```
std::weak_ptr
```
来打破循环引用。
```
std::weak_ptr
```
：
```
std::weak_ptr
```
是一种不拥有对象所有权的智能指针。它指向由
```
std::shared_ptr
```
管理的对象，但不会增加引用计数。
```
std::weak_ptr
```
可以用来检测对象是否仍然存在。

副标题3

移动语义如何提升性能？何时应该使用移动语义？

移动语义通过“窃取”另一个对象的资源来避免不必要的拷贝操作，从而提升性能。它特别适用于以下场景：

返回大型对象： 当函数返回一个大型对象时，移动语义可以避免拷贝构造函数的调用。

MyString createString() {
    MyString str("Hello, world!");
    return str; // str 会被移动到函数调用者
}

临时对象： 当使用临时对象时，移动语义可以避免拷贝构造函数和拷贝赋值运算符的调用。
```
MyString str1 = MyString("Hello");
MyString str2 = std::move(str1); // 将 str1 移动到 str2
```
```
std::move
```
实际上并没有移动任何东西，它只是将一个左值转换为右值引用，使得移动构造函数或移动赋值运算符可以被调用。
```
str1
```
在移动后处于有效但未定义的状态，不应该再使用它，除非重新赋值。
容器操作： 当向容器中插入元素时，移动语义可以避免拷贝操作。例如，
```
std::vector::push_back
```
有一个重载版本，接受右值引用，允许移动元素而不是拷贝元素。
```
std::vector<MyString> vec;
MyString str("Hello");
vec.push_back(std::move(str)); // 将 str 移动到 vec 中
```