C++ - 默认构造函数

构造函数是类的函数，在创建该类的新对象时执行。构造函数与类同名，没有返回类型，甚至没有void。它们主要用于为类的变量提供初始值。构造函数主要有两种类型:默认构造函数和带参数构造函数。

默认构造函数

C++ 默认构造函数不接受任何参数。如果程序员未显式提供默认构造函数，则编译器会提供隐式默认构造函数。在这种情况下，变量的默认值为 0。

语法

默认构造函数的语法如下:

class MyClass {
   public:
      MyClass() {
         // 默认构造函数主体
      }
};

默认构造函数示例

以下程序演示了默认构造函数:

#include <iostream>
using namespace std;
class DemoDC {
   private:
      int num1, num2 ;
   public:
      DemoDC() {
         num1 = 10;
         num2 = 20;
      }
   void display() {
      cout<<"num1 = "<< num1 <<endl;
      cout<<"num2 = "<< num2 <<endl;
   }
};
int main() {
   DemoDC obj;
   obj.display();
   return 0;
}

输出

num1 = 10
num2 = 20

解释

• 这里首先创建了类型为 DemoDC() 的对象，其中默认构造函数自动调用。
• 它用值 10 和 20 初始化类成员 num1 和 num2。
• 然后 display() 方法打印这些值。

隐式与显式默认构造函数

在面向对象编程 (OOP)中，根据默认构造函数的声明方式，它可以分为两类:隐式和显式。

1.隐式默认构造函数

隐式默认构造函数是指在创建对象时由编译器自动调用的构造函数。如果用户传递的参数可以转换为构造函数的形参，则也可能调用该构造函数。

语法

class MyClass {
   int x;
   double y;
};

int main() {
   MyClass obj;  // 调用隐式默认构造函数
}

2. 显式默认构造函数

显式默认构造函数是指编译器在执行自动类型转换或复制初始化时不允许隐式调用该构造函数。换句话说，用户只有在提供匹配的参数时才能直接调用。

语法

class ClassName {
   public:
      explicit ClassName(int x = 10);  // 显式构造函数
};

默认构造函数 vs 参数化构造函数

默认构造函数是指不接受任何参数或所有参数都设置为默认值的构造函数。

而参数化构造函数是指接受一个或多个参数的构造函数。它允许用户在对象创建期间传递值，这些值随后用于对象的初始化。

在本教程中，我们将主要学习默认构造函数。

语法

默认构造函数的语法如下。

class ClassName {
   public:
      // 默认构造函数
      ClassName() {
         // 初始化或设置代码
      }
};

以下是默认构造函数的示例。

说明

• 在此示例中，首先，我们创建了名为 DemoDC 的类。
• 在该类中，声明了两个 int 类型的私有成员变量 num1 和 num2。
• 然后为 DemoDC 类定义一个默认构造函数。当创建类的对象时，会自动调用此构造函数。
• 在此构造函数中，num1 和 num2 分别初始化为 100 和 20。
• 在 int main() 函数中，创建了 DemoDC 类的对象，并触发默认构造函数 DemoDC()。
• obj.display() 显示 num1 和 num2 的值。

何时调用默认构造函数?

默认构造函数在各种情况下都会被调用，主要是在创建对象时不带参数。这里我们将讨论更多调用默认构造函数的情况。

• 当创建对象时没有参数。
• 当类未显式定义任何构造函数时。
• 在派生类中，如果基类具有默认构造函数。
• 当动态分配对象时。

重载默认构造函数

在 C++ 中，重载默认构造函数是指在一个类中创建多个构造函数，每个构造函数都有不同的参数列表，从而允许使用不同的方式初始化对象。

示例

以下是在 C++ 中重载默认构造函数的示例。

#include <iostream>
using namespace std;

class MyClass {
   public:
      int a, b;

      // 默认构造函数(无参数)
      MyClass() : a(0), b(0) {
         cout << "Default constructor called" << endl;
      }

      // 带有一个参数的重载构造函数
      MyClass(int x) : a(x), b(0) {
         cout << "Overloaded constructor (1 argument) called" << endl;
      }

      // 带有两个参数的重载构造函数
      MyClass(int x, int y) : a(x), b(y) {
         cout << "Overloaded constructor (2 arguments) called" << endl;
      }

      void display() {
         cout << "a: " << a << ", b: " << b << endl;
      }
};

int main() {
    MyClass obj1; 			// 调用默认构造函数
    MyClass obj2(10); 		// 调用重载构造函数(1 个参数)
    MyClass obj3(10, 20); 	// 调用重载构造函数(2 个参数)
    
    obj1.display();
    obj2.display();
    obj3.display();
    
    return 0;
}

输出

Default constructor called
Overloaded constructor (1 argument) called
Overloaded constructor (2 arguments) called
a: 0, b: 0
a: 10, b: 0
a: 10, b: 20

解释

• 这里，MyClass() 是默认构造函数，将 a 和 b 初始化为 0。
• MyClass(int x) 是带有一个参数的构造函数，将 a 和 b 分别初始化为 x 和 0。
• MyClass(int x, int y) 是带有两个参数的构造函数，将 a 和 b 分别初始化为 x 和 y。