C++程序输出13-yiteyi-C++库

预测以下C++程序的输出。

null

                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               A                   
                     {                   
                                         // data members of A                   
                     public                               :                   
                                         A ()           { cout <<                               " A's constructor"                               ;                               /* Initialize data members */                               }                   
                                         A (                               const                               A &a) { cout <<                               " A's Copy constructor"                               ;                               /* copy data members */                               }                   
                                         A& operator= (                               const                               A &a)                               // Assignemt Operator                   
                                         {                   
                                         // Handle self-assignment:                   
                                         if                               (                               this                               == &a)                               return                               *                               this                               ;                   
                             
                                         // Copy data members                   
                                         cout <<                               " A's Assignment Operator"                               ;                               return                               *                               this                               ;                   
                                         }                   
                     };                   
                             
                     class                               B                   
                     {                   
                                         A a;                   
                                         // Other members of B                   
                     public                               :                   
                                         B(A &a) {                               this                               ->a = a; cout <<                               " B's constructor"                               ; }                   
                     };                   
                             
                     int                               main()                   
                     {                   
                                         A a1;                   
                                         B b(a1);                   
                                         return                               0;                   
                     }                   

输出：

 A's constructor
 A's constructor
 A's Assignment Operator
 B's constructor

输出的第一行由语句“a1在main（）中。第二行在B的成员“a”初始化时打印。这很重要。第三行由语句“this->a=a在B的构造函数中。第四行由B的构造函数中的cout语句打印。

如果我们仔细看一下上面的代码，B类的构造函数是无效的，因为成员“a”首先是用默认构造函数构造的，然后使用赋值运算符复制参数中的值。当a级课程规模较大时，这可能是一个问题，这通常是许多实际课程的情况。请参阅下面的优化代码。

                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               A                   
                     {                   
                                         // data members of A                   
                     public                               :                   
                                         A()           { cout <<                               " A's constructor"                               ;                               /* Initialize data members */                               }                   
                                         A(                               const                               A &a) { cout <<                               " A's Copy constructor"                               ;                               /* Copy data members */                               }                   
                                         A& operator= (                               const                               A &a)                               // Assignemt Operator                   
                                         {                   
                                         // Handle self-assignment:                   
                                         if                               (                               this                               == &a)                               return                               *                               this                               ;                   
                             
                                         // Copy data members                   
                                         cout <<                               " A's Assignment Operator"                               ;                               return                               *                               this                               ;                   
                                         }                   
                     };                   
                             
                     class                               B                   
                     {                   
                                         A a;                   
                                         // Other members of B                   
                     public                               :                   
                                         B(A &a):a(a) {  cout <<                               " B's constructor"                               ; }                   
                     };                   
                             
                     int                               main()                   
                     {                   
                                         A a;                   
                                         B b(a);                   
                                         return                               0;                   
                     }                   

输出：

 A's constructor
 A's Copy constructor
 B's constructor

类B的构造函数现在使用初始值设定项列表来初始化其成员“a”。使用初始值设定项列表时，B类的成员“a”直接从参数初始化。因此，减少了对a的构造函数的调用。 一般来说，使用初始值设定项列表初始化一个类的所有成员是一个好主意，因为这样可以节省一个额外的成员赋值。 见本文第6点这篇帖子更多细节。

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

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

THE END

技术文章