C++类和对象中的构造函数和析构函数

C++类和对象构造函数和析构函数

1.构造函数（Constructor）

构造函数用于初始化对象的状态。当创建类的对象时，构造函数会被自动调用。构造函数的名字与类名相同，并且没有返回类型（包括void）。

1.示例

class MyClass {
public:
    int x;

    // 构造函数
    MyClass(int val) : x(val) {} // 初始化列表用于初始化成员变量

    // 其他成员函数...
};

int main() {
    MyClass obj(10); // 调用构造函数，创建MyClass对象，并初始化x为10
    // ...
    return 0;
}

2.特点

1. 构造函数可以有参数，也可以没有参数（即默认构造函数）。
2. 构造函数可以被重载，以接受不同类型的参数或不同数量的参数。
3. 如果不提供构造函数，编译器会生成一个默认构造函数（默认构造函数也可能被其他用户定义的构造函数所抑制）。
4. 构造函数不能是虚函数，因为它们在运行时绑定到对象的实际类型，而不是指向对象的指针或引用的类型。

2.析构函数（Destructor）

析构函数用于释放对象使用的资源，并在对象生命周期结束时执行清理操作。析构函数的名字是类名前加上波浪号（~），也没有返回类型（包括void）。

1.示例

class MyClass {
public:
    int* ptr;

    MyClass(int val) {
        ptr = new int(val); // 分配内存
    }

    // 析构函数
    ~MyClass() {
        delete ptr; // 释放内存
    }

    // 其他成员函数...
};

int main() {
    MyClass obj(10); // 调用构造函数
    // ...
    // 当obj离开作用域时，析构函数会自动被调用，释放ptr指向的内存
    return 0;
}

2.特点

1. 每个类只能有一个析构函数。
2. 析构函数没有参数，也不能被重载。
3. 析构函数可以是虚函数，这在处理多态和基类指针指向派生类对象时非常有用（以避免对象切片和资源泄露）。
4. 当对象离开其作用域时（例如，函数结束时），或者对象被删除（对于动态分配的对象）时，析构函数会自动被调用。

构造函数和析构函数是C++面向对象编程中非常重要的概念，它们分别用于初始化对象和清理对象使用的资源。

在C++中，构造函数可以根据其参数和用途进行分类，并且它们的调用时机和方式也有所不同。

3.构造函数的分类

1.默认构造函数

• 无参数的构造函数。
• 如果类中未定义任何构造函数，编译器会自动生成一个默认构造函数（但如果有其他用户定义的构造函数，编译器不会自动生成默认构造函数）。
• 示例：MyClass() {}

2.带参数的构造函数

• 接受一个或多个参数的构造函数。
• 可以根据需求定义多个带参数的构造函数，实现构造函数的重载。
• 示例：MyClass(int val) : x(val) {}

3.拷贝构造函数

• 用于创建一个与现有对象具有相同值的新对象。
• 通常接受一个指向同类型对象的常量引用作为参数。
• 如果类中没有定义复制构造函数，编译器会提供一个默认的拷贝构造函数。
• 示例：MyClass(const MyClass& other) { /* 复制操作 */ }

4.默认构造函数和带参数的构造函数

#include <iostream>

class MyClass {
public:
    int value;

    // 默认构造函数
    MyClass() : value(0) {
        std::cout << "Default constructor called." << std::endl;
    }

    // 带参数的构造函数
    MyClass(int val) : value(val) {
        std::cout << "Parameterized constructor called with value: " << value << std::endl;
    }
};

int main() {
    MyClass obj1; // 调用默认构造函数
    MyClass obj2(10); // 调用带参数的构造函数

    return 0;
}

5.拷贝构造函数

#include <iostream>

class MyClass {
public:
    int value;

    MyClass(int val) : value(val) {
        std::cout << "Parameterized constructor called." << std::endl;
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) : value(other.value) {
        std::cout << "Copy constructor called." << std::endl;
    }
};

int main() {
    MyClass obj1(10); // 调用带参数的构造函数
    MyClass obj2 = obj1; // 调用拷贝构造函数

    // 使用初始化列表也可以调用拷贝构造函数
    MyClass obj3(obj1); // 调用拷贝构造函数

    return 0;
}

4.构造函数的调用

1. 隐式调用
   • 当创建类的对象时，构造函数会被隐式调用。
   • 示例：MyClass obj; // 调用默认构造函数
   • MyClass obj2(10); // 调用带参数的构造函数
2. 显式调用
   • 在某些情况下，可以显式调用构造函数来创建临时对象，但这并不常见。
   • 示例：MyClass temp = MyClass(10); // 虽然这里实际上发生了拷贝构造函数或移动构造函数的调用，但MyClass(10)显式调用了带参数的构造函数
3. 复制初始化与直接初始化
   • 在C++中，可以使用复制初始化或直接初始化来创建对象。
   • 复制初始化使用等号（=），而直接初始化不使用。
   • 示例：MyClass obj1 = 10; // 复制初始化，可能会调用构造函数进行类型转换
   • MyClass obj2(10); // 直接初始化，调用带参数的构造函数

构造函数的调用时机和方式可能受到编译器优化、右值引用和移动语义、C++版本等多种因素的影响。

void test()
{
    //调用无参构造函数
    myClass obj;  // 调用无参构造函数不能加括号
    //调用有参的构造函数
    //括号法
     myClass obj(10);
    //显式调用
    MyClass temp = MyClass(10); //myClass(10)单独调用则为匿名对象，调用后立马析构
    //隐式调用
    MyClass obj1 = 10；  // MyClass obj1 = MyClass(10);
    MyClass obj1 = obj2; //MyClass obj1 = MyClass(obj2);
    
    //不要用拷贝构造函数初始化匿名对象
    MyClass(obj1); //编译器会认为是变量的声明
}

1.构造函数的调用时机

1. 对象通过值传递：当一个对象被作为参数通过值传递给函数时，会调用拷贝构造函数来创建一个新的对象副本。

class MyClass {
public:
    MyClass(const MyClass& other) {
        // 复制构造函数的实现
    }
};

void foo(MyClass obj) {
    // 在这里，MyClass 的对象是通过值传递的，因此会调用拷贝构造函数
}

MyClass obj;
foo(obj); // 调用拷贝构造函数

2. 对象从函数返回时：当函数返回一个对象（不是引用或指针）时，会调用拷贝构造函数来创建一个返回值的副本。

MyClass foo() {
    MyClass obj;
    // ...
    return obj; // 调用拷贝构造函数来创建返回值的副本
}

MyClass obj = foo(); // 调用拷贝构造函数

注意：在现代 C++ 中，对于支持移动语义的类型，编译器可能会选择使用移动构造函数（Move Constructor）而不是拷贝构造函数，以提高性能。

3. 对象被初始化时：当使用已存在的对象来初始化一个新对象时，会调用拷贝构造函数。

MyClass obj1;
MyClass obj2(obj1); // 显式地调用复制构造函数

MyClass obj3 = obj1; // 使用拷贝初始化，也会调用拷贝构造函数

4. 在构造函数中初始化成员变量：如果类的成员变量是另一个类的对象，并且该成员变量在初始化列表中没有被显式地初始化，那么当创建该类的对象时，会调用成员变量的拷贝构造函数（如果成员变量是通过值传递的）。

class OtherClass {
    // ...
};

class MyClass {
    OtherClass oc;
public:
    MyClass(const OtherClass& oc_val) : oc(oc_val) {
        // 在这里，oc 的初始化会调用 OtherClass 的拷贝构造函数
    }
};

OtherClass oc;
MyClass my_obj(oc); // MyClass 的构造函数会调用 OtherClass 的拷贝构造函数

2.构造函数的调用规则

默认情况下，在创建一个类的时，编译器会给我们添加三个函数：构造、析构、拷贝。

构造函数的调用规则：

如果用户定义有有参构造函数，则编译器不再提供无参构造函数。但会提供拷贝构造函数。

如果用户定义有拷贝构造函数，则编译器不再提供其他普通构造函数（析构函数除外）。

首先，如果用户定义了一个或多个有参构造函数，编译器不会自动提供一个无参构造函数（默认构造函数）。但是，如果用户没有定义任何构造函数（包括有参和无参），编译器会提供一个默认的构造函数。

其次，如果用户定义了一个拷贝构造函数，编译器仍然会提供其他必要的特殊成员函数，如默认构造函数（如果用户没有提供）、析构函数和移动构造函数/移动赋值运算符（如果它们没有被显式地禁用或定义）。但是，拷贝构造函数和移动构造函数/移动赋值运算符是用户可以选择定义的，以提供自定义的拷贝和移动语义。

示例 1：只定义有参构造函数

class MyClass {
public:
    MyClass(int value) : m_value(value) {} // 用户定义的有参构造函数
    int m_value;
};

int main() {
    // 下面的代码会编译失败，因为没有默认构造函数
    // MyClass obj; // 错误：没有匹配的构造函数

    // 需要使用有参构造函数
    MyClass obj1(10); // 正确
    MyClass obj2(obj1); // 拷贝构造函数被调用
    return 0;
}

示例 2：定义拷贝构造函数

class MyClass {
public:
    //MyClass(int value) : m_value(value) {} // 用户定义的有参构造函数
    MyClass(const MyClass& other) : m_value(other.m_value) {
        std::cout << "拷贝构造函数被调用" << std::endl;
    } // 用户定义的拷贝构造函数
    int m_value;
};

int main() {
     // 下面的代码会编译失败，因为没有默认和有参构造函数
     // MyClass obj; // 错误：没有匹配的构造函数
   // MyClass obj1(10);错误：没有匹配的构造函数
    MyClass obj2(obj1); // 拷贝构造函数被调用
    return 0;
}

在这个示例中，虽然用户定义了拷贝构造函数，但编译器仍然会提供一个析构函数（如果用户没有定义）。此外，如果用户没有定义移动构造函数或移动赋值运算符，编译器也会提供它们（但在某些情况下，例如当类中有被声明为delete的移动构造函数或移动赋值运算符时，编译器不会提供）。