因为C++语言没有内嵌的GC机制，C++程序员不得不操心动态内存管理的问题。而工程中很多内存管理的问题都是由于违背了rule of three的原则。
按照rule of three的要求，如果一个类显式地定义下列其中一个成员函数，那么其他两个成员函数也应该一起被定义。也就是说这三个函数要么都不定义，要么都要定义。

• 析构函数（destructor）
• 复制构造函数（copy constructor）
• 复制赋值运算符（copy assignment operator）

下面通过一个简单的例子说明违反这个原则所带来的潜在的内存问题。

学生管理系统

学生类的实现

Student类，用来存储学生的姓名及年龄。在构造函数中根据name所指向的字符串的长度按需分配内存，在析构中释放分配的内存以防止内存泄露。

struct Student {
    Student(const char * theName, int theAge)
        : name(createName(theName))
        , age(theAge) {
        std::cout << "construct Student" << std::endl;
    }
    ~Student() {
        std::cout << "destruct Student" << std::endl;
        if (name != NULL) {
            delete[] name;
            name = NULL;
        }
    }
private:
    static char * createName(const char * theName) {
        if (theName == NULL) {
            return NULL;
        }
        char * ptr = new(std::nothrow) char[strlen(theName) + 1];
        if (ptr == NULL) {
            return NULL;
        }
        strcpy(ptr, theName);
        return ptr;
    }
private:
    char * name;
    int age;
};

学校类的实现

学校类用来存储学校里所有的学生信息

struct School {
    void addStudent(const Student & student) {
        students.push_back(student);
    }
private:
    std::vector<Student> students;
};

在main函数中我们构造alice与tom两名学生，并把他们加入到学校中。

int main() {
    Student tom("Tom", 17);
    Student alice("Alice", 16);
    School school;
    school.addStudent(tom);
    school.addStudent(alice);
    return 0;
}

结果分析

编译运行这段代码，发现程序运行出现了内存错误：

运行结果

special member functions

C++标准中规定（参考c++98的标准中Special member functions一节）
如果一个类没有显式地声明以下四个函数，编译器将自动生成默认版本。

• 构造函数(constructor)
• 拷贝构造函数(copy constructor)
• 拷贝赋值操作符(copy assignment)
• 析构函数(destructor)
  由于Student的实现中并没有显式的声明拷贝构造函数，编译器将会自动为Student类创建一个拷贝构造函数。而编译器创建的版本只是单纯地将源对象的每个非static的成员变量拷贝到目标对象。对于Student类，编译器自动生成的拷贝构造函数实现如下：

Student::Student(const Student & rhs) {
    this->name = rhs.name;
    this->age = rhs.age;
}

可以看到，在编译器自动生成的这个版本中，rhs.name所指向的这段内存的指针被赋给了this->name，在这两个对象的析构函数里，都会尝试删除这段内存，从而导致了double free的内存错误。

copy assignment

    Student tom("Tom", 17);
    Student clone("clone", 10);
    clone = tom;

阅读上面的代码，思考在函数退出时会发生啥？
在这段代码中，我们通过copy assignment来clone了一个tom。由于Student类中没有显式地声明copy assignment，编译器为我们自动生成了copy assignment的默认实现。同拷贝构造函数一样，这个函数也只是简单地把源对象中的每一个non-static的成员变量拷贝到目标对象。对于Student类，编译器自动生成的copy assignment函数的如下：

Student & Student::operator = (const Student & rhs) {
    this->name = rhs.name;
    this->age = rhs.age;
    return *this;
}

在执行clone = tom时，clone对象的copy assignment被调用。clone对象里的name指针指向了tom对象的name所指向的指针。在程序退出时，保存字符原先clone.name所指向的内存不会被释放，而tom.name所指向的内存却被释放了两次。（一次是在tom的析构函数中，一次是在clone的析构函数中）

rule of three

上面例子中出现的两个内存问题，都是因为没有遵循role of three。Student类声明并实现了析构函数，却没有同时实现copy constructor与copy assignment operator。
这三个成员函数属于Special member functions，如果没有被显式的定义或禁止，编译器会自动创建它们。如果一个类显式地定义了其中的一个函数，最可能的原因是这个类牵扯到资源的管理，编译器自动生成的版本满足不了类资源管理的需求，因此需要重新实现。那么另外两个函数，也理应做相应的资源相关的操作。
而如果一个类管理的资源不支持copy与共享，就应该明确地拒绝，显式的禁止copy constructor与copy assignment operator，以防止因对象拷贝而带来的资源使用错误。

Student的参考实现1

struct Student {
    Student(const char * theName, int theAge)
        : name(createName(theName))
        , age(theAge) {
        std::cout << "construct Student" << std::endl;
    }
    ~Student() {
        std::cout << "destruct Student" << std::endl;
        if (name != NULL) {
            delete[] name;
            name = NULL;
        }
    }

    Student(const Student & rhs)
        : name(createName(rhs.name))
        , age(rhs.age) {
    }

    Student & operator = (const Student & rhs) {
        if (this->name != NULL) {
            delete [] this->name;
            this->name = NULL;
        }
        if (rhs.name != NULL) {
            this->name = createName(rhs.name);
        }
        this->age = rhs.age;
        return *this;
    }
private:
    static char * createName(const char * theName) {
        if (theName == NULL) {
            return NULL;
        }
        char * ptr = new(std::nothrow) char[strlen(theName) + 1];
        if (ptr == NULL) {
            return NULL;
        }
        strcpy(ptr, theName);
        return ptr;
    }
private:
    char * name;
    int age;
};

Student的参考实现2

在克隆人技术实现之前，copy一个人没有意义，因此需要显式地禁止copy constructor与copy assignment operator（将这两个函数声明为私有而不提供实现）。

struct Student {
    Student(const char * theName, int theAge)
        : name(createName(theName))
        , age(theAge) {
        std::cout << "construct Student" << std::endl;
    }
    ~Student() {
        std::cout << "destruct Student" << std::endl;
        if (name != NULL) {
            delete[] name;
            name = NULL;
        }
    }

private:
    static char * createName(const char * theName) {
        if (theName == NULL) {
            return NULL;
        }
        char * ptr = new(std::nothrow) char[strlen(theName) + 1];
        if (ptr == NULL) {
            return NULL;
        }
        strcpy(ptr, theName);
        return ptr;
    }
private:
    Student(const Student & rhs);
    Student & operator = (const Student & rhs);
private:
    char * name;
    int age;
};

School的实现

由于Student类禁止了拷贝构造函数，而vector在push_back的时候需要调用到对象的拷贝构造函数，因此先前的代码会编译不过，为了解决这个问题，可以在vector中存储Student的指针。在容器中存储指针，消除了对象的构造拷贝，提高了运行效率，但引入了另外一个复杂度，即对象创建与删除职责的管理。

rule of five（C++11）

如果一个类显式定义了destructor、copy constructor、copy assignment operator三个函数中的任意一个函数，编译器不再自动生成move constructor 及move assignment operator的默认实现。如果一个类支持移动语义（move semantics），需要显式地声明并实现这两个函数。这样，对于支持移动语义的类，这五个函数应该同时出现。

参考资料

• 《effective C++》条款05，了解C++默默编写并调用哪些函数
• 《effective C++》条款06，若不想使用编译器自动生成的函数，就该明确拒绝
• 《C++编程规范》第52条，一致地进行复制和销毁

后记

文中例子的运行结果基于mac os + clang，clang版本信息如下：

• Apple LLVM version 7.0.2 (clang-700.1.81)
• Target: x86_64-apple-darwin14.5.0
• Thread model: posix

感谢M23指正，在Linux + gcc的环境下，double free的例子中，析构函数里的log输出了四次。在mac os + clang环境下log输出了三次并不因为析构函数应该被调用三次，而是因为内存异常终止了log的输出。
至于Linux + gcc与mac os + clang异常处理上的不同是另外一个话题，在此不做讨论。