编译器何时在C++中创建默认和复制构造函数？-yiteyi-C++库

构造函数是类的一种特殊类型的成员函数，用于初始化类的对象。在C++中，当创建对象（类的实例）时，将自动调用构造函数。有 三种类型 C++中构造函数的类型：默认构造函数、复制构造函数和参数化构造函数。

null

在C++中，编译器创建默认构造函数如果我们不定义自己的构造函数。在C++中，编译器创建的默认构造函数具有空的主体，即它不向数据成员分配默认值。然而，在Java中默认构造函数指定默认值 .
编译器还创建一个复制构造函数如果我们不编写自己的复制构造函数。与默认构造函数不同，编译器创建的复制构造函数的主体不是空的，它将传递对象的所有数据成员复制到正在创建的对象。

当我们只编写一个复制构造函数时会发生什么？编译器会创建一个复制构造函数吗 默认构造函数？ 如果我们编写任何构造函数，即使它是复制构造函数，编译器也不会创建默认构造函数。例如，以下程序不编译。

CPP

                         // CPP Program to demonstrate what                       
                         // happens when we write                       
                         // only a copy constructor                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
                                   
                         class                                     Point {                       
                                                 int                                     x, y;                       
                                   
                         public                                     :                       
                                                 Point(                                     const                                     Point& p)                       
                                                 {                       
                                                 x = p.x;                       
                                                 y = p.y;                       
                                                 }                       
                         };                       
                                   
                         int                                     main()                       
                         {                       
                                                 Point p1;                       
                                                 // Compiler Error                       
                                                 Point p2 = p1;                       
                                                 return                                     0;                       
                         }                       

输出：

Compiler Error: no matching function for call to 'Point::Point()

当我们写一个普通构造函数而不写一个复制构造函数时会发生什么？

如果我们不编写自己的构造函数，编译器就会创建一个副本构造函数。即使我们在一个类中编写了其他构造函数，编译器也会创建它。例如，下面的程序运行良好。

CPP

                         // CPP Program to demonstrate what happens when we write a                       
                         // normal constructor and don't write a copy constructor                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
                                   
                         class                                     Point {                       
                                                 int                                     x, y;                       
                                   
                         public                                     :                       
                                                 Point(                                     int                                     i,                                     int                                     j)                       
                                                 {                       
                                                 x = 10;                       
                                                 y = 20;                       
                                                 }                       
                                                 int                                     getX() {                                     return                                     x; }                       
                                                 int                                     getY() {                                     return                                     y; }                       
                         };                       
                                   
                         int                                     main()                       
                         {                       
                                                 Point p1(10, 20);                       
                                                 Point p2 = p1;                                     // This compiles fine                       
                                                 cout <<                                     "x = "                                     << p2.getX() <<                                     " y = "                                     << p2.getY();                       
                                                 return                                     0;                       
                         }                       

输出

x = 10 y = 20

因此，只有当我们有指针或运行时资源分配（如文件句柄、网络连接等）时，我们才需要编写副本构造函数。

必须阅读：

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章