C++ 中的构造器和析构器

原文：https://www.studytonight.com/cpp/constructors-and-destructors-in-cpp

构造器是执行每个对象初始化的特殊类函数。每当创建对象时，编译器都会调用构造器。将存储分配给对象后，构造器将值初始化为对象成员。

而另一方面，析构器用于销毁类对象。

在继续学习 C++ 语言中的构造器和析构器之前，请查看以下主题以更好地理解这个概念:

• c++ 中的函数
• c++ 中的类和对象
• 数据成员

让我们先从构造器开始，下面是在类中定义构造器的语法:

class A
{
    public:
    int x;
    // constructor
    A()
    {
        // object initialization
    }
};

定义构造器时，您必须记住构造器的名称将与类的名称相同，并且构造器永远不会有返回类型。

可以使用类名和范围解析::运算符在类定义内部或类定义外部定义构造器。

class A
{
    public:
    int i;
    A(); // constructor declared
};

// constructor definition
A::A()   
{
    i = 1;
}

C++ 中构造器的类型

构造器有三种类型:

1. 默认构造器
2. 参数化构造器
3. 复制构造器

默认构造器

默认构造器是不接受任何参数的构造器。它没有参数。

语法:

class_name(parameter1, parameter2, ...)
{ 
    // constructor Definition 
}

例如:

class Cube
{
    public:
    int side;
    Cube()
    {
        side = 10;
    }
};

int main()
{
    Cube c;
    cout << c.side;
}

Ten

在这种情况下，一旦创建了对象，就调用构造器来初始化其数据成员。

默认构造器对于对象成员的初始化非常重要，即使我们没有显式定义构造器，编译器也会隐式提供默认构造器。

class Cube
{
    public:
    int side;
};

int main()
{
    Cube c;
    cout << c.side;
}

0 或任何随机值

在这种情况下，将调用编译器提供的默认构造器，该构造器将对象数据成员初始化为默认值，在这种情况下，默认值为 0 或任何随机整数值。

参数化构造器

这些是带参数的构造器。使用此构造器，您可以通过传递适当的值作为参数，为不同对象的数据成员提供不同的值。

例如:

class Cube
{
    public:
    int side;
    Cube(int x)
    {
        side=x;
    }
};

int main()
{
    Cube c1(10);
    Cube c2(20);
    Cube c3(30);
    cout << c1.side;
    cout << c2.side;
    cout << c3.side;
}

10 20 30

通过在上面的例子中使用参数化构造器，我们已经用用户定义的值初始化了 3 个对象。我们可以在一个构造器中有任意数量的参数。

复制构造器

这些是特殊类型的构造器，以一个对象为参数，用于将一个对象的数据成员的值复制到另一个对象中。我们后面会详细学习复制构造器。

C++ 中的构造器重载

就像其他成员函数一样，构造器也可以重载。事实上，当您在类中定义了默认和参数化构造器时，您就拥有了重载构造器，一个不带参数，另一个带参数。

一个类中可以有任意数量的构造器，但参数列表不同。

class Student
{
    public:
    int rollno;
    string name;
    // first constructor
    Student(int x)
    {
        rollno = x;
        name = "None";
    }
    // second constructor
    Student(int x, string str)
    {
        rollno = x;
        name = str;
    }
};

int main()
{
    // student A initialized with roll no 10 and name None
    Student A(10);

    // student B initialized with roll no 11 and name John
    Student B(11, "John");
}

在上面的例子中，我们定义了两个具有不同参数的构造器，因此重载了构造器。

还有一点很重要，如果您显式定义了任何构造器，那么编译器将不会提供默认构造器，您必须自己定义它。

在上面的情况下，如果我们在 main() 中写Student S;，会导致编译时出错，因为我们没有定义默认构造器，编译器也不会提供它的默认构造器，因为我们定义了其他参数化的构造器。

C++ 中的析构器

析构器是一种特殊的类函数，一旦对象的作用域结束，它就销毁对象。当对象超出范围时，编译器会自动调用析构器。

析构器的语法与构造器的语法相同，析构器的名称使用类名，前缀为~。

class A
{
    public:
    // defining destructor for class
    ~A() 
    {
        // statement
    }   
};

析构器永远不会有任何参数。

查看如何调用构造器和析构器的示例

下面我们有一个简单的类A，它有一个构造器和析构器。我们将创建类的对象，看看什么时候调用构造器，什么时候调用析构器。

class A
{
    // constructor
    A()
    {
        cout << "Constructor called";
    }

    // destructor
    ~A()
    {
        cout << "Destructor called";
    }
};

int main()
{
    A obj1;   // Constructor Called
    int x = 1
    if(x)
    {
        A obj2;  // Constructor Called
    }   // Destructor Called for obj2
} //  Destructor called for obj1

构造器调用构造器调用析构器调用析构器调用

创建对象时，调用该类的构造器。对象引用在其范围结束时被销毁，通常是在创建它的代码块的右花括号}之后。

当if块结束时，对象obj2被破坏，因为它是在if块内创建的。当main()功能结束时，对象obj1被破坏。

默认构造器和参数化构造器的单一定义

在本例中，我们将使用默认参数为 defualt 和参数化构造器定义一个定义。

class Dual
{
    public:
    int a;
    Dual(int x=0)
    {
        a = x;
    }
};

int main()
{
    Dual obj1;
    Dual obj2(10);
}

这里，在这个程序中，一个单一的构造器定义将负责这两个对象初始化。我们不需要单独的默认构造器和参数化构造器。