类的特殊成员函数——三之法则、五之法则、零之法则

        系统中的动态资源、文件句柄（socket描述符、文件描述符）是有限的，在类中若涉及对此类资源的操作，但是未做到妥善的管理，常会造成资源泄露问题，严重的可能造成资源不可用。或引发未定义行为，进而引起程序崩溃、表现出意外的行为、损坏数据，或者可能看似正常工作但在其它情况下出现问题。

        三之法则和五之法则可以很好地解决上述问题。它们帮助开发者理解和管理类的拷贝控制操作，避免常见的资源泄露、重复释放等问题，并优化程序的性能。零之法则关注类的特殊成员函数的声明和使用。在实际开发中，应根据类的具体需求来决定是否需要自定义这些特殊的成员函数。

一、三之法则

1、概念

        三之法则，也称为“三大定律”或“三法则”，它指出，如果类定义了以下三个特殊成员函数之一：析构函数、拷贝构造函数或拷贝赋值运算符，则开发者通常也需要定义其它两个特殊成员函数，以确保类的拷贝控制和资源管理行为的正确性。

2、使用场景

        三之法则主要是为了避免资源泄露、重复释放或其它由于浅拷贝导致的错误。

        默认情况下，编译器会为类生成默认的析构函数、拷贝构造函数和拷贝赋值运算符，但这些默认实现通常只进行浅拷贝，即只复制对象的成员变量的值，而不复制成员变量所指向的资源。如果成员变量是指针，并且指向动态分配的内存，则浅拷贝会导致两个对象共享同一块内存，从而在销毁时发生重复释放的错误。

3、如何实现

定义所有需要的特殊成员函数：如果类需要自定义其中一个特殊成员函数，那么通常也需要自定义其他两个成员函数，以确保对象的拷贝和赋值行为符合预期。

理解资源管理：了解类所管理的资源，并决定是否需要自定义特殊成员函数来管理这些资源的拷贝和赋值。

使用RAII：将资源的生命周期与对象的生命周期绑定，简化资源管理，降低资源泄露风险。

4、示例

4.1 类中包含指针私有成员

#include <iostream>
#include <cstring>class Point {  
public:  Point(size_t n = 0) : numCoords(n), coords(n ? new double[n] : nullptr){if (coords) {std::memset(coords, 0, n * sizeof(double));}}~Point(){delete[] coords;}Point(const Point &other) : numCoords(other.numCoords), coords(new double[other.numCoords]){std::memcpy(coords, other.coords, numCoords * sizeof(double));}Point &operator=(const Point &other){  if (this != &other) {delete[] coords;numCoords = other.numCoords;coords = new double[numCoords];std::memcpy(coords, other.coords, numCoords * sizeof(double));}return *this;}  private:  double *coords; size_t numCoords;
};  int main() 
{Point p1(3);Point p2 = p1;Point p3;p3 = p1;return 0;
}

二、五之法则

1、概念

        五之法则在C++11及以后版本引入，它在三之法则的基础上增加了两个新的特殊成员函数：移动构造函数和移动赋值运算符，以支持移动语义。

2、使用场景

        五之法则的引入是为了进一步提高程序的性能，特别是在处理大型对象或资源密集型对象时。通过允许对象之间的资源移动而不是复制，可以减少不必要的内存分配和释放操作，从而提高程序的运行效率。

3、如何实现

定义所有五个特殊成员函数：如果类需要移动语义，则应该定义所有五个特殊成员函数（析构函数、拷贝构造函数、拷贝赋值运算符、移动构造函数和移动赋值运算符）。

使用noexcept关键字：在C++11及以后版本中，移动构造函数和移动赋值运算符通常会被标记为noexcept，表明它们不会抛出异常。这有助于编译器优化代码，并允许在更多情况下使用移动语义。

理解移动语义：了解移动语义的工作原理，并决定何时以及如何使用它来优化程序的性能。

4、示例

4.1 socket描述符

#include <iostream>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdexcept>class SocketDescriptor {
public:// 默认构造函数，创建一个无效的socketSocketDescriptor() : fd(-1) {}// 构造函数，接受一个已创建的socket文件描述符explicit SocketDescriptor(int socket_fd) : fd(socket_fd){if (fd == -1) {throw std::runtime_error("Invalid socket descriptor");}}// 析构函数，关闭socket文件描述符  ~SocketDescriptor(){closeSocket();}// 禁用拷贝构造函数SocketDescriptor(const SocketDescriptor&) = delete;// 禁用拷贝赋值运算符SocketDescriptor& operator=(const SocketDescriptor&) = delete; // 移动构造函数SocketDescriptor(SocketDescriptor&& other) noexcept : fd(other.fd){other.fd = -1; // 将原对象的fd置为无效}// 移动赋值运算符SocketDescriptor& operator=(SocketDescriptor&& other) noexcept{if (this != &other) {closeSocket(); // 关闭当前对象的fdfd = other.fd; // 转移资源other.fd = -1; // 将原对象的fd置为无效}return *this;}// 获取socket文件描述符int get() const{return fd;}// 创建一个新的socket并管理它static SocketDescriptor createSocket(int domain, int type, int protocol){int fd = socket(domain, type, protocol);if (fd == -1) {throw std::runtime_error("Failed to create socket");}return SocketDescriptor(fd);}// 关闭socket文件描述符
private:void closeSocket(){if (fd != -1) {::close(fd);fd = -1;}}private:int fd;
};int main()
{try {// 创建一个新的TCP socketSocketDescriptor sock = SocketDescriptor::createSocket(AF_INET, SOCK_STREAM, 0);// 打印socket文件描述符std::cout << "Socket descriptor: " << sock.get() << std::endl; } catch (const std::exception& e) {std::cerr << "Error: " << e.what() << std::endl;}return 0;
}

4.2 拷贝"大"数据

#include <iostream>
#include <algorithm> // 用于std::copy
#include <stdexcept> // 用于std::runtime_error 和 std::bad_alloc 的异常处理class LargeData {
public:LargeData() = default;// 构造函数，接受数据大小并初始化数据explicit LargeData(size_t dataSize){try {data = new char[dataSize];this->dataSize = dataSize;std::fill_n(data, dataSize, 0); // 初始化数据为0（可选）} catch (const std::bad_alloc&) {throw std::runtime_error("Memory allocation failed in LargeData constructor");}}// 析构函数，释放动态分配的数据~LargeData(){delete[] data;}// 拷贝构造函数，执行深拷贝LargeData(const LargeData& other) : dataSize(other.dataSize){try {data = new char[dataSize];std::copy(other.data, other.data + dataSize, data);} catch (const std::bad_alloc&) {throw std::runtime_error("Memory allocation failed in LargeData copy constructor");}}// 拷贝赋值运算符，执行深拷贝LargeData& operator=(const LargeData& other){if (this == &other) {return *this; // 自赋值检查}// 释放当前对象的资源char* oldData = data;// 分配新资源并复制数据try {dataSize = other.dataSize;data = new char[dataSize];std::copy(other.data, other.data + dataSize, data);} catch (const std::bad_alloc&) {// 如果新分配失败，恢复旧状态并抛出异常dataSize = 0; // 或者保持原大小，但这可能会导致不一致状态data = oldData; // 这里实际上不应该这样做，因为oldData可能已经被释放或指向无效内存throw std::runtime_error("Memory allocation failed in LargeData copy assignment operator");}return *this;}// 移动构造函数，接管资源（之前已经正确实现）LargeData(LargeData&& other) noexcept : dataSize(0), data(nullptr){*this = std::move(other); // 委托给移动赋值运算符}// 移动赋值运算符，接管资源并释放旧数据（之前已经正确实现）LargeData& operator=(LargeData&& other) noexcept{if (this == &other) {return *this; // 自赋值检查}// 释放当前对象的资源delete[] data;// 接管其他对象的资源data = other.data;dataSize = other.dataSize;// 重置其他对象的资源指针以避免悬挂指针other.data = nullptr;other.dataSize = 0;return *this;}// 获取数据大小size_t getSize() const{return dataSize;}// 获取数据指针（注意：返回的指针不应被删除）const char* getData() const{return data;}// 非const版本的getData，用于修改数据（通常不推荐这样做，但为了完整性而提供）char* getData(){return data;}// 设置数据（示例函数，用于修改数据内容，注意大小必须匹配）void setData(const char* newData, size_t newSize){if (newSize != dataSize) {throw std::runtime_error("New data size does not match existing data size");}std::copy(newData, newData + newSize, data);}private:size_t dataSize; // 数据大小char* data;      // 指向动态分配数据的指针
};int main()
{try {// 创建大量数据对象LargeData data1(1024); // 1KB数据// 使用拷贝构造函数LargeData data2 = data1; // data2是data1的深拷贝// 使用拷贝赋值运算符LargeData data3;data3 = data1; // data3现在是data1的深拷贝// 清理资源（由析构函数自动处理）} catch (const std::exception& e) {std::cerr << "Exception: " << e.what() << std::endl;}return 0;
}

三、零之法则

1、概念

        C++的零之法则是指，如果可能，类应该避免声明任何特殊成员函数。鼓励让编译器自动生成这些特殊成员函数，以简化类的设计和管理。

2、使用场景

简化设计：零之法则通过减少需要编写的代码量，简化类的设计。当类不需要显式管理资源时，遵循零之法则可以使类的接口更加清晰。

减少错误：手动编写特殊成员函数容易引入错误，特别是当类的成员变量较多或类型复杂时。编译器生成的特殊成员函数通常更加健壮。

利用标准库：零之法则鼓励使用标准库组件（如std::string、std::vector等）来管理资源。

提高可维护性：遵循零之法则的类更加简洁，更易于理解和维护。

3、如何实现

避免显式声明特殊成员函数：除非类需要显式管理资源，否则让编译器自动生成这些函数。

使用组合而非继承：组合优于继承是面向对象设计中的一个重要原则。通过组合，可以将其它类的实例作为当前类的成员变量，从而避免复杂的继承关系和虚函数的开销。

利用智能指针：对于需要动态分配内存的场景，使用C++11及以后版本中引入的智能指针（如std::unique_ptr、std::shared_ptr等）。这些智能指针可以自动管理内存，减少内存泄漏的风险。

4、示例

4.1 合理使用C++标准库管理内存

#include <iostream>
#include <stdexcept>
#include <string>class LargeData {
public:// 默认构造函数，创建一个空的LargeData对象LargeData() = default;// 构造函数，接受数据大小（以字节为单位）并初始化一个相应大小的空字符串explicit LargeData(size_t dataSize) : data(dataSize, '\0') {}// 获取数据大小（以字节为单位）size_t getSize() const{return data.size();}// 获取数据（返回const char*以避免修改数据）const char* getData() const{return data.c_str();}// 非const版本的getData，用于修改数据（通常不推荐这样做，但为了完整性而提供）// 注意：这允许调用者修改数据，但他们必须确保不超出字符串的边界。char* getData() {return &data[0];}// 设置数据（注意：大小必须匹配，否则抛出异常）void setData(const char* newData, size_t newSize){if (newSize != data.size()) {throw std::runtime_error("New data size does not match existing data size");}data.assign(newData, newSize);}// 为了方便，添加一个接受std::string的setData重载void setData(const std::string& newData){if (newData.size() != data.size()) {throw std::runtime_error("New data size does not match existing data size");}data = newData;}private:std::string data; // 使用std::string来存储数据
};int main() 
{try {// 创建LargeData对象，大小为1024字节LargeData data1(1024);// 使用拷贝构造函数（由编译器隐式生成）LargeData data2 = data1; // data2是data1的一个深拷贝（因为std::string是深拷贝的）// 使用拷贝赋值运算符（由编译器隐式生成）LargeData data3;data3 = data1; // data3现在是data1的一个深拷贝// 注意：不需要手动清理资源，因为std::string会处理它} catch (const std::exception& e) {std::cerr << "Exception: " << e.what() << std::endl;}return 0;
}

4.2 智能指针管理资源

#include <iostream>
#include <memory>
#include <vector>// 一个简单的类，表示资源
class Resource {
public:Resource(int value) : value_(value){std::cout << "Resource created with value: " << value_ << std::endl;}~Resource(){std::cout << "Resource destroyed with value: " << value_ << std::endl;}void display() const{std::cout << "Resource value: " << value_ << std::endl;}
private:int value_;// 禁止拷贝和赋值Resource(const Resource&) = delete;Resource& operator=(const Resource&) = delete;
};// 一个管理类，使用智能指针管理资源
class ResourceManager {
public:void addResource(int value){// 使用std::make_unique来创建unique_ptrresources_.push_back(std::make_unique<Resource>(value));}void displayAllResources() const{for (const auto& resource : resources_) {resource->display();}}private:std::vector<std::unique_ptr<Resource>> resources_;
};int main()
{// 创建ResourceManager对象ResourceManager manager;// 添加资源manager.addResource(10);manager.addResource(20);manager.addResource(30);// 显示所有资源manager.displayAllResources();// ResourceManager对象离开作用域时，其析构函数会调用，所有unique_ptr会自动释放资源return 0;
}