C++ 八股文：构造函数

运气好到爆

已于 2023-10-18 14:27:24 修改

阅读量152

点赞数

文章标签： c++ java javascript

于 2023-10-18 14:12:06 首次发布

本文链接：https://blog.csdn.net/m0_38086244/article/details/133903768

版权

什么是构造函数

构造函数（Constructor）是一种特殊的成员函数，用于在创建对象时进行初始化。它的作用是确保对象在创建后处于一个合法和可用的状态。构造函数在类定义中声明，其名称与类名相同，但不带返回类型。

写一个拷贝构造函数？为什么你写的是引用传递？而不是值传递？（除了效率上的问题外）

拷贝构造函数用于创建一个对象的拷贝，通常在以下情况下使用：

通过值传递方式将对象传递给函数。
通过值返回方式从函数返回对象。
在创建一个对象作为另一个对象的拷贝时（如对象初始化或赋值）。

拷贝构造函数通常使用引用传递，而不是值传递，因为值传递会导致对象的无限递归复制，陷入无限循环。这是因为拷贝构造函数本身会创建一个新对象，如果将参数传递给拷贝构造函数时使用值传递，会导致无限递归的拷贝。

以下是一个示例拷贝构造函数，使用引用传递参数：

class MyObject {
public:
    int value;

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

int main() {
    MyObject obj1;
    obj1.value = 42;

    // 通过拷贝构造函数创建 obj2 作为 obj1 的拷贝
    MyObject obj2 = obj1;

    // obj1 和 obj2 现在有相同的值
    std::cout << obj1.value << " " << obj2.value << std::endl;

    return 0;
}

在上述示例中，拷贝构造函数 MyObject(const MyObject& other) 接受一个引用参数，这样可以避免无限递归的拷贝。如果我们将参数改为值传递，将导致无限循环的拷贝，直到栈溢出。

除了效率问题，使用引用传递还可以避免不必要的资源分配和释放。通过引用传递，只是传递了对象的引用而不是整个对象的拷贝，因此效率更高。此外，使用引用传递也更符合对象的语义，因为拷贝构造函数的目的是创建一个新对象，而不是复制对象的所有内容。所以，使用引用传递是一种更好的做法。

构造函数重载：

作用：
- 初始化对象的成员变量。
- 分配和管理资源，如内存分配、文件打开、数据库连接等。
- 执行其他必要的初始化操作。

语法：

class ClassName {
public:
    // 默认构造函数（无参数）
    ClassName() {
        // 构造函数的实现
    }

    // 带参数的构造函数
    ClassName(Type1 param1, Type2 param2, ...) {
        // 构造函数的实现
    }
};

构造函数的语法示例中：

ClassName 是类的名称。
public 部分用于指定构造函数的访问权限，通常是公共的，以允许外部代码创建对象。
构造函数的名称与类名相同。
可以定义多个构造函数，每个构造函数具有不同的参数列表，允许不同的对象初始化方式。

为什么构造函数不能为虚函数？

构造函数不能为虚函数的原因是与对象的创建和初始化顺序以及虚函数机制有关。虚函数的特性和构造函数的执行顺序之间存在矛盾，因此构造函数不能被声明为虚函数。以下是相关的解释：

对象的初始化顺序：对象的初始化是按照继承层次从基类到派生类的顺序进行的。首先，基类的构造函数被调用，然后依次调用派生类的构造函数。这个初始化顺序是固定的。
虚函数的调用依赖于对象的类型：虚函数的调用是依赖于对象的类型的，而不是对象的构造过程。当对象被创建时，它在构造函数内部还没有完全初始化，因此对象的类型可能尚未被确定。虚函数调用要等到对象完全初始化后才有意义。

由于构造函数在对象的初始化阶段执行，而虚函数的调用依赖于对象的完全初始化，将构造函数声明为虚函数会导致潜在问题：

构造函数声明为虚函数会导致不确定性，因为在构造函数内部，对象的类型可能还不确定，虚函数调用可能会指向错误的实现。
基类构造函数的调用是在派生类构造函数之前发生的，因此派生类的虚函数表尚未完全设置，使得虚函数无法正确调用。
```
class Base {
public:
    virtual void foo() {
        // 虚函数
    }

    Base() {
        foo(); // 构造函数中调用虚函数
    }
};

class Derived : public Base {
public:
    void foo() override {
        // 派生类的虚函数实现
    }
};
```
在这个示例中，如果 Base 的构造函数声明为虚函数，那么在调用 foo() 时，派生类的虚函数实现还没有生效，因此无法调用正确的虚函数。这是为什么构造函数不能为虚函数的一个示例。

总之，构造函数不能声明为虚函数，因为虚函数的调用依赖于对象的完全初始化，而构造函数的目标是初始化对象。为了避免潜在的问题和不确定性，最好将构造函数保持为普通的成员函数，而将虚函数用于对象完全初始化后的多态操作。

构造函数使用private

将构造函数声明为private是一种封装技巧，它通常用于实现单例模式、工厂模式或其他只允许有限途径创建对象的情况。当构造函数被声明为private时，只有类内部的函数可以访问它，外部代码无法直接创建类的实例。

下面是一个示例，展示了如何将构造函数声明为private：

class Singleton {
public:
    // 获取唯一的实例
    static Singleton& getInstance() {
        static Singleton instance; // 在首次调用时创建唯一的实例
        return instance;
    }

    // 其他成员函数
    void doSomething() {
        // 执行操作
    }

private:
    // 构造函数私有，防止外部代码直接创建对象
    Singleton() {
        // 构造函数的实现
    }

    // 防止复制和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

在上述示例中，构造函数Singleton()被声明为private，防止外部代码直接创建Singleton类的实例。相反，通过公共的静态成员函数getInstance()来获取唯一的实例。这确保了只有一个Singleton对象存在。

通过将构造函数声明为private，你可以实现更严格的对象创建控制，确保对象的唯一性，同时提供一个公共的方法来获取实例。这在单例模式等情况下非常有用。

构造函数的初始化列表和构造函数体内的赋值操作之间有一些重要的区别：

执行时间:
- 初始化列表：构造函数初始化列表在进入构造函数体之前执行。这意味着它们在对象的成员变量构造之前执行，可以在构造函数体内访问这些成员变量。
- 构造函数体内的赋值：赋值操作在构造函数体内执行，因此它们在对象的成员变量已经构造之后执行。这意味着它们不能在构造函数体内初始化成员变量。
效率:
- 初始化列表：使用初始化列表通常更高效，因为它直接初始化成员变量，而不是先默认初始化然后再赋值。
- 构造函数体内的赋值：在构造函数体内赋值需要两步操作：首先默认初始化成员变量，然后再进行赋值操作，可能会引入额外的开销。
成员变量的类型:
- 初始化列表：适用于非静态成员变量和const成员变量，以及基本类型（如int、double）。
- 构造函数体内的赋值：在构造函数体内可以用于更多的情况，包括对非const成员变量、静态成员变量和复杂类型（如类对象）的初始化。
顺序:
- 初始化列表：允许你指定成员变量的初始化顺序，即使它们在类中的声明顺序不同。这有助于避免潜在的问题，如依赖于初始化顺序的成员变量之间的问题。
- 构造函数体内的赋值：通常依赖于成员变量的声明顺序，因此如果声明顺序与所需初始化顺序不同，可能需要小心。