类设计者的核查表

第一篇 如何设计类

你的类需要复制构造函数吗

在 C++ 中，如果一个类的对象只包含基本数据类型或其他具有合理复制构造函数的成员类型，并且没有动态分配的资源（如动态数组、指针等），那么这个类通常不需要自定义复制构造函数。此时，编译器生成的默认复制构造函数就足够了。

何时不需要自定义复制构造函数

1. 只包含基本数据类型：
   如果类只包含基本数据类型（如 int、float、char 等），那么默认的复制构造函数会按值复制这些成员，通常没有问题。

   class SimpleClass {
   public:
       SimpleClass(int a, float b) : a(a), b(b) {}
       
       // 不需要自定义复制构造函数
   private:
       int a;
       float b;
   };
   

2. 包含其他类的对象：
   如果类的成员是其他类的对象，并且这些类也定义了合理的复制构造函数（通常是自动生成的），那么同样不需要自定义复制构造函数。

   class MemberClass {
   public:
       MemberClass(int x) : x(x) {}
   private:
       int x;
   };
   
   class MyClass {
   public:
       MyClass(int a, int b) : member(b) {} // member 会调用 MemberClass 的复制构造函数
   private:
       int a;
       MemberClass member;
   };
   

3. 没有动态分配的资源：
   如果类不管理动态分配的资源（例如，使用 new 分配内存），则可以依赖默认的复制构造函数。

何时需要自定义复制构造函数

如果类的成员中有以下情况之一，则需要自定义复制构造函数：

1. 动态分配的资源：
   如果类管理动态分配的内存或其他资源，则需要提供自定义的复制构造函数，以确保进行深拷贝，避免多个对象共享同一资源。
   一个类在构造函数内申请资源，则可能需要一个显示的复制构造函数来管理资源以及一个析构函数来释放构造函数分配的资源

   class MyClass {
   public:
       MyClass(int size) : size(size) {
           data = new int[size];
       }
   
       // 自定义复制构造函数
       MyClass(const MyClass& other) {
           size = other.size;
           data = new int[size]; // 深拷贝
           std::copy(other.data, other.data + size, data);
       }
   
       ~MyClass() {
           delete[] data; // 释放内存
       }
   
   private:
       int* data;
       int size;
   };
   

2. 需要特定的复制逻辑：
   如果在复制过程中需要执行特定的逻辑（如更新计数、记录日志等），也需要自定义复制构造函数。

总结

如果一个类的对象只包含基本数据类型和其他具有合理复制构造函数的成员类型，并且不管理任何动态资源，那么就可以依赖编译器生成的默认复制构造函数，无需自定义。然而，一旦涉及到动态资源管理或需要特殊的复制逻辑，就必须提供自定义的复制构造函数。

什么时候需要将构造函数和赋值运算符设置为私有？

在 C++ 中，将构造函数和赋值运算符设为私有的情况通常与以下几种设计模式和需求相关：

1. 单例模式（Singleton Pattern）

在单例模式中，类的目的是保证只有一个实例存在。为了防止外部代码创建多个实例，构造函数和赋值运算符通常被设为私有，并提供一个公共的静态方法来获取该类的唯一实例。

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance; // 线程安全的静态局部变量
        return instance;
    }

    // 禁止复制和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {} // 私有构造函数
};

2. 禁止复制和赋值

在某些情况下，类的设计可能不希望其对象被复制或赋值。例如，管理独占资源的类（如文件句柄、网络连接等）通常会将复制构造函数和赋值运算符设为私有或删除，这样可以避免不必要的资源共享和潜在的错误。

class UniqueResource {
public:
    UniqueResource() {
        // 资源初始化
    }

    // 禁止复制和赋值
    UniqueResource(const UniqueResource&) = delete;
    UniqueResource& operator=(const UniqueResource&) = delete;

    // 其他成员函数...

private:
    // 资源数据
};

3. 工厂模式（Factory Pattern）

在工厂模式中，构造函数可能被设为私有，以强制使用工厂方法生成对象。这种情况下，类的实例化过程被封装在工厂类中，从而控制对象的创建和生命周期。

class Product {
public:
    // 工厂方法
    static Product* createProduct() {
        return new Product(); // 在工厂方法中创建实例
    }

private:
    Product() {} // 私有构造函数
};

4. 实现某些设计模式

某些设计模式（如代理模式、适配器模式等）可能需要将构造函数和赋值运算符设为私有，以控制对象的创建和管理。

5. 限制类的实例化

在某些情况下，类可能只需要在某个特定上下文中被实例化。例如，某些库可能需要限制用户直接创建类的实例，以确保类的使用符合特定的逻辑或状态。

总结

将构造函数和赋值运算符设为私有通常用于：

• 单例模式：确保类只有一个实例。
• 禁止复制和赋值：防止不必要的资源共享和潜在的错误。
• 工厂模式：通过工厂方法控制对象的创建。
• 实现某些设计模式：如代理模式、适配器模式等。
• 限制类的实例化：确保类的使用符合特定的逻辑或状态。

通过这种方式，类的设计者可以更好地控制类的使用和实例化，确保资源的正确管理和避免潜在的错误。

如果函数有引用参数，他们应该是const引用吗

什么时候使用非const引用

No1. 如果要在函数的内部修改引用的值是不要加const的

	Complex operator+(Complex& other) const {
		// 假设我们希望在这里修改 x 和 y 的值
    	this.real += 1; // 修改 x 的实部
    	other.imag += 1; // 修改 y 的虚部
        return Complex(this.real+ other.real, this.imag + other.imag);
    }

但是通常情况下是没有这种需求的，而且这种用法不支持连续加法（a+b+c），因为前面两个对象相加（a+b）产生的临时对象是不能赋值给非const引用的对象的，所以只能适用于自定义二元加法运算。所以对于加法运算符一般采用const引用

左值与右值的概念

• 左值（lvalue）：可以被赋值的对象，具有持久的内存地址。例如，变量、数组元素等。
• 右值（rvalue）：临时对象，没有持久的内存地址，通常是表达式的结果。比如 x + y 的结果是一个临时的 Complex 对象。

1. 传递大型对象（如类实例）

当函数需要传递大型对象（例如，用户自定义的类或结构体），使用 const 引用是一个很好的选择，以避免不必要的复制开销，同时又能保证函数不会修改传入的对象。例如：

class LargeObject {
    // 具体实现
};

void processObject(const LargeObject& obj) {
    // 处理 obj，但不修改它
}

在这种情况下，使用 const 引用可以提高性能，并确保安全性。

2. 传递基本数据类型（如 int、float 等）

对于基本数据类型（如 int、float 等），通常不需要使用引用，因为它们的大小相对较小，直接传值更简单，且不会有性能损失。因此，以下写法更常见：

void processInt(int value) {
    // 处理 value
}

当然，如果你希望函数能够修改传入的值，可以使用非 const 引用：

void modifyInt(int& value) {
    value += 10; // 修改传入的值
}

3. 需要修改对象的情况

如果函数需要修改传入的对象，则应使用非 const 引用。例如：

void modifyObject(LargeObject& obj) {
    // 修改 obj
}

什么使用const引用

 // 重载加法运算符
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

测试程序

#include <iostream>

class Complex {
public:
    Complex(double real = 0.0, double imag = 0.0) : real(real), imag(imag) {}

    // 重载加法运算符
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    void print() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }

private:
    double real;
    double imag;
};

int main() {
    Complex c1(1.0, 2.0);
    Complex c2(3.0, 4.0);
    Complex c3 = c1 + c2; // 使用重载的 + 运算符
    c3.print(); // 输出: 4.0 + 6.0i

	Complex a(3.0, 4.0);
	Complex b(3.0, 4.0);
	Complex c(3.0, 4.0);
	Complex sum = a+b+c;//正确
    
    return 0;
}

最后解释一下两个参数的加法运算符，这种适合z=a+b，同样不适合连续加法（a+b+c）因为参数不对。

Complex operator+(const Complex& x, const Complex& y) {
    return Complex(x.real + y.real, x.imag + y.imag);
}

并且这种方法不能放在类内声明， “此运算符函数的参数太多”

所以要在类外声明，同时注意私有成员，对象无法访问。

Complex operator+(Complex& a, Complex& b){
        return Complex(a.getReal() + b.getReal(), a.getImag() + b.getImag());
    }

双参数加法运算符不能在类内定义，但是双目加法运算符+=可以，为什么它就能定义在类内了呢？

因为 y+=z。此时是需要y的值的，也就是说，在真正计算的时候，是需要this的值的，所以应该定义在类内。

编译器会自动检查，若双目运算符定义在类内，则最多只能有一个入参，因为this也算一个。