[C++] 默认构造函数、参数化构造函数、拷贝构造函数、移动构造函数及其使用案例

什么是构造函数？

C++构造函数是一种特殊的成员函数，用于创建和初始化类的对象。它在对象被创建时自动调用，并负责对对象的成员变量进行初始化。构造函数的名称与类的名称相同，它没有返回类型，包括默认构造函数、参数化构造函数、拷贝构造函数和移动构造函数等形式。

默认构造函数是没有参数的构造函数，在创建对象时如果没有显式地指定构造函数，则会自动调用默认构造函数。

参数化构造函数包含了一个或多个参数，用于初始化对象的成员变量。

拷贝构造函数用于创建一个新对象，并将其初始化为已有对象的副本。

构造函数可以用来执行一些初始化操作，例如为成员变量分配内存，将成员变量设置为特定的值，或者执行其他必要的初始化工作。构造函数也可以被重载，即一个类可以有多个不同参数的构造函数，以便创建不同的对象。

移动构造函数是C++11引入的一种特殊的构造函数，用于在对象被移动时，将资源从一个对象转移到另一个对象，而不是进行复制操作。

移动构造函数通常用于提高代码的性能，在处理大型对象或动态分配的内存时特别有用。通过移动构造函数，可以避免不必要的内存拷贝和分配，减少对象之间的数据传输。

移动构造函数的语法与拷贝构造函数类似，但是参数列表前有一个特殊的右值引用（&&）修饰符，表示传递的对象可以被移动。 

构造函数的使用可以提高代码的可读性和维护性，确保对象在创建时具有合适的初始状态。

构造函数使用案例

以下是关于默认构造函数、参数化构造函数、拷贝构造函数和移动构造函数的一些示例：

默认构造函数

默认构造函数是一个无参构造函数，用于创建对象时不需要传递任何参数。例如：

class MyClass {
public:
    // 默认构造函数
    MyClass() {
        // 初始化对象的成员变量
    }
};

// 使用默认构造函数创建对象
MyClass obj;

参数化构造函数

参数化构造函数接收一个或多个参数，用于初始化对象的成员变量。例如：

class MyClass {
public:
    // 参数化构造函数
    MyClass(int value) {
        // 初始化对象的成员变量
    }
};

// 使用参数化构造函数创建对象
MyClass obj(10);

拷贝构造函数

拷贝构造函数用于创建一个对象，其成员变量与已有对象相同。例如：

class MyClass {
public:
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        // 将other对象的成员变量拷贝给当前对象
    }
};

// 使用拷贝构造函数创建对象
MyClass obj1;
MyClass obj2(obj1);

移动构造函数

移动构造函数用于将资源从一个对象转移到另一个对象，而不是进行复制操作。例如：

class MyClass {
public:
    // 移动构造函数
    MyClass(MyClass&& other) {
        // 将资源从other对象转移给当前对象
    }
};

// 使用移动构造函数创建对象
MyClass obj1;
MyClass obj2(std::move(obj1));

以上是各种构造函数的基本示例，具体实现可以根据具体需求进行修改和扩展。

std::move是C++标准库中的一个函数模板，它用于将一个对象转换为右值引用。通过使用std::move，可以显式地标记对象，以指示其资源可以被移动或转移。

std::move的定义如下：

template <typename T>
typename remove_reference<T>::type&& move(T&& arg) noexcept;

std::move接受一个参数arg，并返回一个T&&类型的右值引用。通过将参数arg转换为右值引用，std::move表明该对象的资源可以被移动或转移。

使用std::move的主要目的是在移动语义中提供一种明确的方式来标记对象，以避免不必要的拷贝。通过使用移动构造函数或移动赋值运算符，可以在移动语义中将资源从一个对象转移到另一个对象，而无需进行额外的内存分配和拷贝。

以下是std::move的使用示例：

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";

    // 使用std::move将str1转移到str2
    std::string str2 = std::move(str1);

    // 此时str1的值未定义
    std::cout << "str1: " << str1 << std::endl;  // 输出: str1:

    // 输出str2的值
    std::cout << "str2: " << str2 << std::endl;  // 输出: str2: Hello

    return 0;
}

在上述示例中，我们使用std::move将str1转移到str2，并且在移动之后，str1的值变为未定义。这是因为std::move将str1标记为右值引用，使得资源可以被移动给str2，而不是进行拷贝。这样可以提高效率，并避免不必要的资源分配和拷贝。

综合案例一

以下是一个使用拷贝构造函数的案例：

#include <iostream>

class MyClass {
public:
    int value;

    // 默认构造函数
    MyClass() {
        value = 0;
    }

    // 参数化构造函数
    MyClass(int val) {
        value = val;
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        value = other.value;
    }

    void displayValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    // 创建对象
    MyClass obj1(10);

    // 使用拷贝构造函数创建对象
    MyClass obj2(obj1);

    // 修改obj1的值
    obj1.value = 20;

    // 打印obj1和obj2的值
    obj1.displayValue();  // 输出: Value: 20
    obj2.displayValue();  // 输出: Value: 10

    return 0;
}

在上述案例中，我们首先通过参数化构造函数创建了一个对象obj1，并将其值初始化为10。然后，我们使用拷贝构造函数创建了另一个对象obj2，并将obj1的值拷贝给了obj2。接着，我们修改了obj1的值为20，但obj2的值没有改变。这是因为拷贝构造函数会将obj1的成员变量值拷贝给obj2，而不是共享同一份数据。

综合案例二

以下是一个使用移动构造函数的案例：

#include <iostream>

class MyString {
public:
    char* data;

    // 默认构造函数
    MyString() {
        data = nullptr;
    }

    // 参数化构造函数
    MyString(const char* str) {
        int length = strlen(str) + 1;
        data = new char[length];
        strcpy_s(data, length, str);
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        int length = strlen(other.data) + 1;
        data = new char[length];
        strcpy_s(data, length, other.data);
    }

    // 移动构造函数
    MyString(MyString&& other) {
        data = other.data;
        other.data = nullptr;
    }

    ~MyString() {
        if (data != nullptr) {
            delete[] data;
        }
    }

    void displayData() {
        std::cout << "Data: " << data << std::endl;
    }
};

int main() {
    // 创建对象
    MyString str1("Hello");

    // 使用移动构造函数创建对象
    MyString str2(std::move(str1));

    // 打印str1和str2的数据
    // str1.displayData();  // str1的data资源已经被转移到str2,调用str1的displayData会引发空指针异常。 
    str2.displayData();  // 输出: Data: Hello

    return 0;
}

在上述案例中，我们首先通过参数化构造函数创建了一个MyString对象str1，并将其初始化为"Hello"。然后，我们使用移动构造函数将str1的资源移动给了str2。这样做既避免了资源的多次拷贝，又防止了删除str1时重复删除资源。在移动后，str1的data指针被设置为nullptr，而str2则拥有了移动前的资源。