C++中類的構造函數調用順序

C++中類的構造函數調用順序

當建立一個對象時，首先調用基類的構造函數，然後調用下一個派生類的
構造函數，依次類推，直至到達派生類次數最多的派生次數最多的類的構造函數為止。
簡而言之，對象是由“底層向上”開始構造的。因為，構造函數一開始構造時，總是
要調用它的基類的構造函數，然後才開始執行其構造函數體，調用直接基類構造函數時，
如果無專門說明，就調用直接基類的默認構造函數。在對象析構時，其順序正好相反。

下面的這個程序說明這個問題

 

總結下來，我們必須明確的是當一個類繼承與基類，並且自身還包含有其他類的成員對象的時候，構造函數的調用順序為：調用基類的構造函數->調用成員對象的構造函數->調用自身的構造函數。構造函數的調用次序完全不受構造函數初始化列表的表達式中的次序影響，與基類的聲明次數和成員對象在函數中的聲明次序有關。

 

 

1. C++子類和父類的構造函數調用順序 
   1. #include
   2. using namespace std;
   3.  
   4. //子類
   5. class base
   6. {
   7. public:
   8. base()
   9. {
   10. cout< }
   11. };
   12. //父類
   13. class drived : public base
   14. {
   15. public:
   16. drived()
   17. {
   18. cout< }
   19. };
   20. int main()
   21. {
   22. drived d;
   23. //輸出結果
   24. /*
   25. i am base constuction!
   26. i am drived constuction!
   27. Press any key to continue
   28. */
   29. return 0;
   30. }
       由輸出結果我們可以看到，先調用的是base類的構造函數，再調用了drived類的構造函數，也就是說，在聲明子類實例的時候，是會先調用父類的構造函數的。這個很好理解，子類是包含了父類的信息的，所以要構造子類，必須先構造父類的信息，然後加入一些子類的新信息。
       成員類的構造函數調用順序
       1. #include
       2. using namespace std;
       3.  
       4. class son
       5. {
       6. public:
       7. son()
       8. {
       9. cout< }
       10. };
       11. class family
       12. {
       13. public:
       14. family()
       15. {
       16. cout< }
       17. son jack;
       18.  
       19. };
       20.  
       21.  
       22. int main()
       23. {
       24. family happyfamily;
       25. //輸出結果
       26. /*
       27. i am son constuction!
       28. i am family constuction!
       29. Press any key to continue
       30.  
       31. */
       32. return 0;
       33. }
           從上面的結果我們科看到，先調用的是構造函數。這是為什麼？因為類中含有成員類時，先要給成員類申請空間，先調用成員類的構造函數，然後再調用自身的構造函數。
            
           1. #include
           2. using namespace std;
           3. //父親姓名
           4. class name
           5. {
           6. public:
           7. name()
           8. {
           9. cout< }
           10. };
           11. //子類
           12. class base
           13. {
           14. public:
           15. base()
           16. {
           17. cout< }
           18. };
           19. //父類
           20. class drived : public base
           21. {
           22. public:
           23. drived()
           24. {
           25. cout< }
           26. name drivedname;
           27. };
           28.  
           29. int main()
           30. {
           31. drived d;
           32. //輸出結果
           33. /*
           34. i am base constuction!
           35. i am name constuction!
           36. i am drived constuction!
           37. Press any key to continue
           38.  
           39. */
           40. return 0;
           41. }
               上面的例子是聲明了一個name類，一個base類，一個drived類，其中drived類是從base類派生，且drived類中聲明了name類的一個實例。那麼根據我們上面的分析，我們聲明了drived類之後，先會調用父類構造函數，也就是輸出i am base construction，然後調用自身的成員類構造函數，也就是i am name construction，最後調用自身的構造函數，也就是i am drived construction。同理，如果我們在父類base類中聲明了name成員類的話，順序會是name->base->drived。我下面給出測試例子： 
               1. #include
               2. using namespace std;
               3. //父親姓名
               4. class name
               5. {
               6. public:
               7. name()
               8. {
               9. cout< }
               10. };
               11. //子類
               12. class base
               13. {
               14. public:
               15. base()
               16. {
               17. cout< }
               18. name drivedname;
               19. };
               20. //父類
               21. class drived : public base
               22. {
               23. public:
               24. drived()
               25. {
               26. cout< }
               27.  
               28. };
               29.  
               30. int main()
               31. {
               32. drived d;
               33. //輸出結果
               34. /*
               35. i am name constuction!
               36. i am base constuction!
               37. i am drived constuction!
               38. Press any key to continue
               39. */
               40. return 0;
               41. }