c++ 构造函数和拷贝构造

构造函数

1. 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
2. 构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。
3. 构造函数可用于为某些成员变量设置初始值。
   例子如下：

#include <iostream>
#include <string>

using namespace std;  // 使用std命名空间

class Car {
public:
    string brand;
    int year;

    // 无参构造函数
    Car() {
        brand = "未知";
        year = 0;
        cout << "无参构造函数被调用" << endl;
    }

    void display() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    Car myCar; // 创建Car对象
    myCar.display(); // 显示车辆信息

    return 0;
}

带参数构造函数

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

#include <iostream>
#include <string>

using namespace std;  // 使用std命名空间

class Car {
public:
    string brand;  // 不需要使用std::string
    int year;

    // 无参构造函数
    Car() {
        brand = "未知";
        year = 0;
        cout << "无参构造函数被调用" << endl;  // 不需要使用std::cout和std::endl
    }

    // 带参数的构造函数，使用常规的赋值方式
    Car(string b, int y) {
        brand = b;
        year = y;
    }


    void display() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
//    Car myCar; // 创建Car对象
    Car myCar2("Toyota", 2020); // 使用带参数的构造函数创建Car对象

    myCar2.display(); // 显示车辆信息

    return 0;
}

拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

1. 当一个新对象被创建为另一个同类型的现有对象的副本时：
   • 例如：MyClass obj1 = obj2; 或 MyClass obj1(obj2);，其中 obj2 是现有的对象。
2. 将对象作为参数传递给函数时（按值传递）：
   • 当对象作为参数传递给函数，并且参数不是引用时，会使用拷贝构造函数创建函数内部的对象副本。
3. 从函数返回对象时（按值返回）：
   • 当函数返回对象，并且没有使用引用或指针时，拷贝构造函数用于从函数返回值创建副本。
4. 初始化数组或容器中的元素时：
   • 例如，在创建一个包含对象的数组时，数组中的每个对象都是通过拷贝构造函数初始化的。

拷贝构造函数的典型声明如下：

class MyClass {
public:
    MyClass(const MyClass& other);
};

其中，other 是对同类型对象的引用，通常是常量引用。

#include <iostream>
#include <string>

using namespace std;

class Car {
public:
    string brand;
    int year;

    // 常规构造函数
    Car(string b, int y) : brand(b), year(y) {}

    // 拷贝构造函数
    Car(const Car& other) {
        brand = other.brand;
        year = other.year;
        cout << "拷贝构造函数被调用" << endl;
    }

    void display() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

int main() {
    Car car1("Toyota", 2020);  // 使用常规构造函数
    Car car2 = car1;           // 使用拷贝构造函数

    car1.display();
    car2.display();

    return 0;
}

在 C++ 中，深拷贝和浅拷贝是处理对象拷贝时的两种不同方法，尤其是在对象包含指针或动态分配的内存时。以下分别给出深拷贝和浅拷贝的例子。

浅拷贝(Shallow Copy)

浅拷贝只复制对象的成员变量的值。如果成员变量是指针，则复制指针的值（即内存地址），而不是指针所指向的实际数据。这会导致多个对象共享相同的内存地址。

#include <iostream>
using namespace std;

class Shallow {
public:
    int* data;


    Shallow(int d) {
         //(d)：这是初始化表达式。在这里，分配的 int 类型内存被初始化为 d 的值。如果 d 的值是 20，那么分配的内存将被初始化为 20。
        data = new int(d); // 动态分配内存
        cout << "观察数据：" << endl;
        cout << d << endl;
        cout << *data << endl;

        cout << "观察内存在构造函数中：" << endl;
        cout << data << endl;
    }

    // 默认的拷贝构造函数是浅拷贝
    ~Shallow() {
        delete data; // 释放内存
    }
};

int main() {
    Shallow obj1(20);

    Shallow obj2 = obj1; // 浅拷贝

    cout << "观察内存在main函数obj2的data地址：" << endl;
    cout << obj2.data << endl;

    cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;

    return 0;
}

在这个例子中，obj2 是通过浅拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向相同的内存地址。
当 obj1 和 obj2 被销毁时，同一内存地址会被尝试释放两次，导致潜在的运行时错误。
在QT中我们不能直观看见，在Linux中我们获得如下运行结果：

深拷贝（deep copy）

深拷贝复制对象的成员变量的值以及指针所指向的实际数据。这意味着创建新的独立副本，避免了共享内存地址的问题。

#include <iostream>
using namespace std;

class Deep {
public:
    int* data;

    Deep(int d) {
        data = new int(d); // 动态分配内存

        cout << "观察数据：" << endl;
        cout << d << endl;
        cout << *data << endl;

        cout << "观察内存在构造函数中：" << endl;
        cout << data << endl;
    }

    // 显式定义深拷贝的拷贝构造函数
    Deep(const Deep& source) {
        data = new int(*source.data); // 复制数据，而不是地址
        cout << "深拷贝构造函数\n";
    }

    ~Deep() {
        delete data; // 释放内存
    }
};

int main() {
    Deep obj1(20);

    Deep obj2 = obj1; // 深拷贝
    cout << "观察内存在main函数obj2的data地址：" << endl;
    cout << obj2.data << endl;


    cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;

    return 0;
}

在这个例子中，obj2 是通过深拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向不同的内存地址。每个对象有自己的内存副本，因此不会相互影响，避免了潜在的运行时错误。

在c++的面向对象中，需要遵循以下三个规则。
如果你需要显式地定义或重载类的任何一个拷贝控制操作（拷贝构造函数、拷贝赋值运算符、析构函数），那么你几乎肯定需要显式地定义或重载所有三个。这是因为这三个功能通常都是用于管理动态分配的资源，比如在堆上分配的内存。

下面是一个遵循规则三则的简单示例：

#include <iostream>
#include <cstring>

class MyClass {
private:
    char* buffer;

public:
    // 构造函数
    MyClass(const char* str) {
        if (str) {
            buffer = new char[strlen(str) + 1];
            strcpy(buffer, str);
        } else {
            buffer = nullptr;
        }
    }

    // 析构函数
    ~MyClass() {
        delete[] buffer;
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        if (other.buffer) {
            buffer = new char[strlen(other.buffer) + 1];
            strcpy(buffer, other.buffer);
        } else {
            buffer = nullptr;
        }
    }

    // 拷贝赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete[] buffer; // 首先删除当前对象的资源
            if (other.buffer) {
                buffer = new char[strlen(other.buffer) + 1];
                strcpy(buffer, other.buffer);
            } else {
                buffer = nullptr;
            }
        }
        return *this;
    }
};

int main() {
    MyClass obj1("Hello");
    MyClass obj2 = obj1; // 调用拷贝构造函数
    MyClass obj3("World");
    obj3 = obj1; // 调用拷贝赋值运算符

    return 0;
}

在这个例子中：

• 构造函数为成员变量 buffer 分配内存，并复制给定的字符串。
• 析构函数释放 buffer 所占用的内存，以避免内存泄露。
• 拷贝构造函数创建一个新对象作为另一个现有对象的副本，并为其分配新的内存，以避免多个对象共享同一内存。
• 拷贝赋值运算符更新对象时，首先释放原有资源，然后根据新对象的状态分配新资源。

这个类遵循规则三则，确保了动态分配资源的正确管理，避免了内存泄露和浅拷贝问题。