C++构造函数用于 初始化一个类的实例的成员变量，该实例是一个类的对象。 构造函数是一种特殊类型的成员函数，它在创建一个对象时自动初始化该对象。编译器通过它的名字和返回类型将一个给定的成员函数识别为一个构造函数。
C++构造函数
C++中的构造器是一个类的成员函数。构造函数与类的名称相同，没有返回类型。而且，构造函数总是公开的。
但它们在以下方面与实际函数不同：
- 构造函数的名称与类的名称相同。
- 构造函数没有返回类型，与其他成员函数不同。
- 如果在一个类中没有明确定义构造函数，就会自动调用一个默认的构造函数。
- 如果我们没有指定一个构造函数，C++编译器就会为我们生成一个默认的构造函数（不期望有任何参数，并且有一个空心体）。
构造函数是如何工作的？
每当创建一个类的实例时，一个与该类同名的没有任何返回类型的成员函数会被自动调用。即使这个构造函数没有明确定义，仍然会调用一个默认的构造函数。
由于它是一个函数，它可以接受参数并有一个函数体。所以，可以通过显式定义自定义构造函数将参数传递给它，在它的主体内部，传递的参数可以用来初始化成员变量。
构造函数的使用
构造函数，顾名思义，通常用于在创建一个类的对象时自动初始化该类对象的成员变量。假设有一个矩形类，它存储了矩形的长度、宽度和面积。
同时，它还有一些处理它的成员函数。如果我们希望每当一个矩形类的对象被创建时，长度、宽度和面积应该被自动初始化。那么，在这种情况下，构造函数被用来初始化这些变量。
C++中构造函数的类型
默认构造函数
顾名思义，如果我们在定义类的时候没有明确定义一个构造函数，那么就会调用一个没有参数和空心体的默认构造函数。
为了检查这一点，我们可以明确地在这个默认构造函数的主体内写一个print语句来检查它是否被调用。当一个类的实例或对象被创建时，默认构造函数将被自动调用。
下面提到的代码在创建A类的对象 "obj "时自动调用默认构造函数。它由默认构造函数中的print函数显示，该函数向外流输出 "*默认构造函数被调用！"。
请看下面c++代码中的默认构造函数：
#include <iostream>
using namespace std;
class A
{
int x,y;
public:
A()
{
cout << "Default constructor called!";
}
};
int main()
{
// Sample Code to show default constructor
A obj; // making a object of class A
return 0;
}
请看下面的输出：
参数化构造函数
与默认构造函数不同，在参数化构造函数中，我们可以将初始化一个类的对象的成员变量的值作为参数传递。
它与我们传递参数的普通函数相同；唯一的区别是它没有返回类型。它更像是函数重载，因为我们可以为一组不同的输入参数拥有一组不同的构造函数，这被称为构造函数重载。
参数化构造函数可以用两种方式调用，即 显式 和 隐式：
class_name obj = class_name(parameter1,parameter2); // Explicit way
class_name obj(parameter 1,parameter 2); //Implicit way
这两种方式的作用与初始化类的对象的成员变量相同。
在下面提到的代码中，类A包含两个成员变量， x，和y。此外，对象 obj被创建，参数值为10，和20被传递给它 。
在这里，调用了参数化构造函数的隐式调用。然后在参数化构造函数的正文中，'x=a'和'y=b'初始化了对象的成员变量：
#include <iostream>
using namespace std;
class A
{
int x,y;
public:
A()
{
cout << "Default constructor called!";
}
A(int a,int b)
{
x = a; // Initializing
y = b;
cout << "Parameterized constructor called!\n";
}
void print()
{
cout << x << " " << y << "\n";
}
};
int main()
{
// Sample Code to show default constructor
A obj(10,20); // making a object of class A -- >Implicit
obj.print();
return 0;
}
请看下面的输出：
复制构造函数
它与其他两个构造函数有些不同，因为它是用来用同一类别的另一个对象的值来初始化一个对象的成员变量的。
同类的另一个对象在参数中作为引用被传递，然后被用来初始化相关对象的成员变量。
当一个函数返回一个对象或一个对象被作为参数传递给一个函数时，通常会调用它。它的定义语法如下：
class_name( const class_name & object_of_same_class );
当旧对象被传递一个参数时，旧对象的成员变量的值可以被明确地分配给新对象的成员。
在下面提到的代码中，有两个对象， obj和obj2， 已经被创建。
第一个对象只是上节中使用的参数化构造函数。 obj2 被初始化为对象 obj 的成员变量的值 ， 在创建对象 obj2 时 绕过了 obj 这个参数 。 'x=old.x'和'y=old.y'是将旧对象的值分配给新对象：
#include <iostream>
using namespace std;
class A
{
int x,y;
public:
A()
{
cout << "Default constructor called!";
}
A(int a,int b)
{
cout << "Parameterized Constructor called!\n";
x=a;
y=b;
}
A(const A & old )
{
// old is the old object being passed
x = old.x; //This object's x to old object's x
y = old.y;
cout << "Copy Constructor called!\n";
}
void print()
{
cout << x << " " << y << "\n";
}
};
int main()
{
// Sample Code to show default constructor
A obj(10,20); // making a object of class A -- >Implicit
A obj2(obj); // Copy Constructor called old object 'obj' is passed
obj2.print();
return 0;
}
请看下面的输出：
构造函数重载
由于构造函数与函数非常相似，构造函数重载也与函数重载非常相似。
因此，不同的构造函数可以根据传递的不同参数集被调用。然而，所有构造函数的名称都与类的名称相同。
在下面提到的代码中，不同的构造函数是根据传递的不同参数来调用的。A类有两个构造函数，一个没有任何参数，也就是默认的构造函数，另一个带有参数'a'和'b'。
两个对象，obj1和obj2被创建。在obj1中，没有参数的构造函数被调用。带参数的obj2构造函数被调用，因为参数'10′和'20'已经被传递给它。
它设置了obj2的成员变量，'x=a'和'y=b'。
请看下面的代码：
#include <iostream>
using namespace std;
class A
{
int x,y;
public:
A()
{
cout << "Default constructor called!\n";
}
A(int a,int b)
{
x = a; // Initializing
y = b;
cout << "Parametrized constructor called!\n";
}
void print()
{
cout << x << " " << y << "\n";
}
};
int main()
{
// Sample Code to show constructor overloading.
A obj1; //Default constructor called.
A obj2(10,20); // Parametrized constructor called.
obj2.print();
return 0;
}
请看下面的输出：
本教程就到此为止。
