# C++ 构造器

> 原文： [https://www.programiz.com/cpp-programming/constructors](https://www.programiz.com/cpp-programming/constructors)

#### 在本文中，您将学习 C++ 中的构造器。 您将学习什么是构造器，如何创建它以及 C++ 中的构造器类型。

构造器是成员函数的一种特殊类型，它在创建[对象](/cpp-programming/object-class "C++ objects")时自动对其进行初始化。

编译器通过其名称和返回类型将给定的成员函数标识为构造器。

构造器与类具有相同的名称，并且没有任何返回类型。 同样，构造器始终是公共的。

```cpp
... .. ...
class temporary
{
private: 
	int x;
	float y;
public:
	// Constructor
	temporary(): x(5), y(5.5)
	{
		// Body of constructor
	}
	... ..  ...
};

int main()
{
	Temporary t1;
	... .. ...
}

```

上面的程序显示了定义的构造器，没有返回类型，并且名称与类相同。

* * *

## 构造器如何工作？

在上面的伪代码中，`temporary()`是构造器。

创建类`temporary`的对象时，将自动调用构造器，并且`x`初始化为 5，`y`初始化为 5.5。

您还可以按如下所示初始化构造器体内的数据成员。 但是，这种方法不是优选的。

```cpp
temporary()
{
   x = 5;
   y = 5.5;
}
// This method is not preferred.
```

* * *

## 在 C++ 中使用构造器

假设您正在处理 100 个`Person`对象，并且数据成员`age`的默认值为 0。手动初始化所​​有对象将是一项非常繁琐的任务。

相反，您可以定义一个将`age`初始化为 0 的构造器。然后，您要做的就是创建`Person`对象，该构造器将自动初始化`age`。

这些情况在处理对象数组时经常出现。

另外，如果要在创建对象后立即执行一些代码，可以将代码放在构造器的主体内。

* * *

### 示例 1：C++ 中的构造器

**计算并显示矩形的面积。**

```cpp
#include <iostream>
using namespace std;

class Area
{
    private:
       int length;
       int breadth;

    public:
       // Constructor
       Area(): length(5), breadth(2){ }

       void GetLength()
       {
           cout << "Enter length and breadth respectively: ";
           cin >> length >> breadth;
       }

       int AreaCalculation() {  return (length * breadth);  }

       void DisplayArea(int temp)
       {
           cout << "Area: " << temp;
       }
};

int main()
{
    Area A1, A2;
    int temp;

    A1.GetLength();
    temp = A1.AreaCalculation();
    A1.DisplayArea(temp);

    cout << endl << "Default Area when value is not taken from user" << endl;

    temp = A2.AreaCalculation();
    A2.DisplayArea(temp);

    return 0;
}

```

在该程序中，创建了`Area`类来处理与区域相关的功能。 它具有两个数据成员`length`和`width`。

定义了一个构造器，该构造器将`length`初始化为 5，将`width`初始化为 2。

我们还具有三个附加的成员函数`GetLength(), AreaCalculation() and DisplayArea()`，以从用户处获取长度，计算面积并分别显示面积。

当创建对象`A1`和`A2`时，由于构造器的缘故，两个对象的`length`和`width`分别初始化为 5 和 2。

然后，调用成员函数`GetLength()`，该函数从对象获取对象`A1`的`length`和`width`的值。 这改变了对象`A1`的长度和宽度。

然后，通过调用`AreaCalculation()`函数计算对象`A1`的区域并将其存储在变量`temp`中，最后将其显示。

对于对象`A2`，没有要求用户提供任何数据。 因此，`length`和`width`分别保持为 5 和 2。

然后，计算并显示`A2`的面积为 10。

**输出**

```cpp
Enter length and breadth respectively: 6
7
Area: 42
Default Area when value is not taken from user
Area: 10
```

* * *

## 构造器重载

构造器可以类似于[函数重载](/cpp-programming/function-overloading "C++ Function overloading")的方式重载。

重载的构造器具有相同的名称（类的名称），但参数数量不同。

根据传递的参数的数量和类型，将调用特定的构造器。

由于存在多个构造器，因此在创建对象时也应传递该构造器的参数。

* * *

## 示例 2：构造器重载

```cpp
// Source Code to demonstrate the working of overloaded constructors
#include <iostream>
using namespace std;

class Area
{
    private:
       int length;
       int breadth;

    public:
       // Constructor with no arguments
       Area(): length(5), breadth(2) { }

       // Constructor with two arguments
       Area(int l, int b): length(l), breadth(b){ }

       void GetLength()
       {
           cout << "Enter length and breadth respectively: ";
           cin >> length >> breadth;
       }

       int AreaCalculation() {  return length * breadth;  }

       void DisplayArea(int temp)
       {
           cout << "Area: " << temp << endl;
       }
};

int main()
{
    Area A1, A2(2, 1);
    int temp;

    cout << "Default Area when no argument is passed." << endl;
    temp = A1.AreaCalculation();
    A1.DisplayArea(temp);

    cout << "Area when (2,1) is passed as argument." << endl;
    temp = A2.AreaCalculation();
    A2.DisplayArea(temp);

    return 0;
} 
```

对于对象`A1`，在创建对象时不传递任何参数。

因此，将调用不带参数的构造器，该构造器会将`length`初始化为 5，将`width`初始化为 2。因此，对象`A1`的面积将为 10。

对于对象`A2`，在创建对象时将 2 和 1 作为参数传递。

因此，将调用具有两个参数的构造器，该构造器将`length`初始化为`l`（在这种情况下为 2），并将`breadth`初始化为`b`（1 在这种情况下）。 因此，对象`A2`的面积将为 2。

**输出**

```cpp
Default Area when no argument is passed.
Area: 10
Area when (2,1) is passed as argument.
Area: 2 
```

* * *

## 默认复制构造器

一个对象可以用另一个相同类型的对象初始化。 这与将一个类的内容复制到另一个类相同。

在上述程序中，如果要初始化对象`A3`使其包含与`A2`相同的值，则可以执行以下操作：

```cpp
....
int main()
{
   Area A1, A2(2, 1);

   // Copies the content of A2 to A3
   Area A3(A2);
     OR, 
   Area A3 = A2;
}
```

您可能会认为，您需要创建一个新的构造器来执行此任务。 但是，不需要其他构造器。 这是因为默认情况下，复制构造器已内置到所有类中。