2. 程式人生 > >C++中關於全域性物件的初始化順序

C++中關於全域性物件的初始化順序

阿新 • • 發佈：2019-01-25

在stackoverflow上看到下面這樣一個問題：

這個問題很簡單，意思就是兩個全域性不同類的instance，其中一個依賴另一個，怎麼確保他們的構造順序。也就是說O2依賴於o1,o2被例項化之前，我們要確保o1一定要被構造出來，或者說初始化。就上面來看，如果這樣兩個全域性變數o1和o2在同一個編譯單元，說白了就是在同一個cpp檔案裡，那麼編譯器會保證按照他們出現的順序初始化。但是如果這樣兩個全域性變數在不同的編譯單元呢，這時候情況比較複雜了，編譯器已經不能控制他們的構造順序了，我們需要自己想辦法確定他們的構造順序，因為編譯器不能定義不同編譯單元全域性變數的初始化順序。下面是我的sample code，

這兩個全域性變數分別在不同的編譯單元，請看程式碼：
//************Independent.h*************************

#ifndef INDEPENDENT_H

#define INDEPENDENT_H

class Independent

{

    public:

        Independent();

        virtual ~Independent();

    protected:

    private:

};

#endif // INDEPENDENT_H


//**********************Independent.cpp*******************************

#include "Independent.h"

#include <iostream>

using namespace std;

Independent::Independent()

{

    cout<<"Independent::Independent()."<<endl;

}

Independent::~Independent()

{

    cout<<"Independent::~Independent()."<<endl;

}

Independent o1;

//*********************Dependent.h*****************************

#ifndef DEPENDENT_H

#define DEPENDENT_H

#include "Independent.h"

class Dependent

{

    public:

        virtual ~Dependent();

        Dependent();

    protected:

    private:

};

#endif // DEPENDENT_H



//***********************Dependent.cpp*****************************************

#include "Dependent.h"

#include <iostream>

#include "Independent.h"

using namespace std;

Dependent::Dependent()

{

    cout<<"Dependent::Dependent()."<<endl;

}

Dependent::~Dependent()

{

    cout<<"Dependent::~Dependent()."<<endl;

}

Dependent o2;



//***********************************main.cpp*********************************

int main()
{
    return 0;
}


程式的執行結果：

很明顯o2是在o1之前被構造出來的，這個應該是編譯器隨機選擇的，我們不能確定o2和o1他們兩個之間的構造順序。

下面是一些辦法，確定o1在o2之前一定被構造出來，因為在很多實際應用中，一些全域性物件依賴於另一些全域性物件的，雖然我們儘可能要少用全域性變數，不過今天討論的問題跟這個無關。請看修改過的程式碼：


點選(此處)摺疊或開啟

  1. //*************Independent.h********************
  2. #ifndef INDEPENDENT_H
  3. #define INDEPENDENT_H
  4. class Independent
  5. {
  6.     public:
  7.         Independent();
  8.         virtual ~Independent();
  9.     protected:
  10.     private:
  11. };
  12. #endif // INDEPENDENT_H


點選(此處)摺疊或開啟

  1. //*************Independent.cpp********************
  2. #include "Independent.h"
  3. #include <iostream>
  4. using namespace std;
  5. Independent::Independent()
  6. {
  7.     cout<<"Independent::Independent(), o1"<<endl;
  8. }
  9. Independent::~Independent()
  10. {
  11.     cout<<"Independent::~Independent()."<<endl;
  12. }
  13. const Independent *o1;


點選(此處)摺疊或開啟

  1. //*************dependent.h********************
  2. #ifndef DEPENDENT_H
  3. #define DEPENDENT_H
  4. #include "Independent.h"
  5. class Dependent
  6. {
  7.     public:
  8.         virtual ~Dependent();
  9.         Dependent(Independent* a);
  10.     protected:
  11.     private:
  12.         Dependent();
  13. };
  14. #endif // DEPENDENT_H


點選(此處)摺疊或開啟

  1. //*************Dependent.cpp********************
  2. #include "Dependent.h"
  3. #include <iostream>
  4. #include "Independent.h"
  5. using namespace std;
  6. extern Independent *o1;
  7. Dependent::Dependent()
  8. {
  9.     cout<<"Dependent::Dependent(), o2"<<endl;
  10. }
  11. Dependent::Dependent(Independent* a)
  12. {
  13.     if(a == NULL)
  14.         a = new Independent();
  15.     cout<<"Dependent::Dependent(Independent* a) o2"<<endl;
  16. }
  17. Dependent::~Dependent()
  18. {
  19.     cout<<"Dependent::~Dependent()."<<endl;
  20. }
  21. Dependent o2(o1);


點選(此處)摺疊或開啟

  1. //*************main.cpp********************
  2. #include <iostream>
  3. using namespace std;
  4. int main()
  5. {
  6.     return 0;
  7. }

下面是程式執行的結果：


很明顯，o2依賴於o1， 而o1也在o2之前被構造出來了。

總結：

1.我們要儘可能少用全域性變數

2.可以將一個物件的建構函式作為另一個物件建構函式的引數來保證他們的構造順序


閱讀(1586) | 評論(1) | 轉發(3) | 給主人留下些什麼吧！~~ 11_avatar_small.jpg

2013-09-16 23:40:12

貌似effectivec++裡有更好的辦法你可以看一下

回覆 | 舉報 評論熱議

相關推薦

C語言中全域性變數初始化的重要性！！！

在C語言裡，全域性變數如果不初始化的話，預設為0，也就是說在全域性空間裡： 　　int x =0; 跟 int x; 的效果看起來是一樣的。但其實這裡面的差別很大，強烈建議大家所有的全域性變數都要初始化，他們的主要差別如下： 　　編譯器在編譯的時候針對這兩種情況會產生兩種符

如何調整Linux核心啟動中的驅動初始化順序-驅動載入優先順序

轉載自：http://zhidao.baidu.com/link?url=adCsiTiI7i3QVYrTx19jkt_FvBV2VlQ4NV18pEu6Kdi4Yhv0ryauD3LHj1pxGE-YP8M_PxZnHNy-hVKBvzJOkPfqehZmR9CQm5GZ5XZDx-O Lin

c++ 類成員變數初始化順序

#include <iostream> using namespace std; class A { public: //使用初始化列表初始化時，與定義成員變數的順序有關。 //因為成員變數的初始化次序是根據變數在

C++中只能使用初始化列表（只能是初始化）不能使用賦值的情況

（1）當類中含有const（常量）、reference（引用）成員變數時，只能初始化，不能對它們進行賦值；      常量不能被賦值，只能被初始化，所以必須在初始化列表中完成，C++引用也一定要初始化，所以必須在初始化列表中完成。 （2）基類的建

C++中變數預設初始化規則

轉載連結地址：http://www.cnblogs.com/FoxShark/p/5802239.html 定義沒有初始化式的變數時，系統有時候會幫我們初始化變數。系統如何初始化取決於變數的型別以及變數定義的位置。 　　1、內建型別變數是否自動初始化取決於變數定義的位置。函式體外定義的變

C++中的值初始化和預設初始化

1、值初始化       顧名思義，就是用數值初始化變數。如果沒有給定一個初始值，就會根據變數或類物件的型別提供一個初始值。對於int型別其值初始化後的值為0。 2、預設初始化：如果定義變數時沒有指定初值，則變數被預設初始化。其初始值和變數的型別以及變數定義的位

淺談java類中成員的初始化順序(一)

類被建立之後的成員的初始化順序到底是怎麼樣的？ 首先 不考慮繼承 package com; public class DemoOne { /** * 關於類的初始化順序 */ //不考慮繼承結構的情況 private static int a;

重新認識memset函式及c++中陣列的初始化賦值

下面就好好重新認識一下這個函式，自己寫了測試的程式碼，memset到底怎麼用呢？ 先貼測試程式碼： #include<iostream> #include<cstdio> #include<algorithm> #include<string>

C語言全域性未初始化資料段分析

前言：         在分析C語言全域性未初始化變數時，發現在目標檔案中全域性未初始化變數並不是直接放在bss段中。         再後來發現在兩個.c檔案中定義同名的全域性變數，連結時居然沒有

[基礎知識]1.C++成員變數的初始化順序？

下列程式的執行結果分別是？ class A { private: int n1; int n2; public: A():n2(0),n1(n2+2019){} void Print(){ cout << "n1:" << n1 <<

Spring中Bean的初始化順序

1.構造程式或者工廠方法建立Bean例項 2.為Bean屬性設定值和Bean引用 3.呼叫感知介面中定義的設定方法 4.將Bean例項傳遞給每個Bean後處理器中的postProcessBeforeI

C++中必須在初始化列表初始化的型別

1.賦值是刪除原值，賦予新值，建構函式的意思是先開闢空間然後為其賦值，只能算是賦值，不算初始化；初始化列表開闢空間與初始化是同時完成的，直接給予一個值。 2. C++中常量是不能被賦值的，只能被初始化，所以const型別必須在初始化列表中完成； 3. 引用必須在定義的時候初

關鍵字static及物件初始化順序

以下內容參考：https://www.cnblogs.com/dolphin0520/p/3799052.html 1.static 變數 靜態變數和非靜態變數的區別： 靜態變數在方法區被所有的物件所共享，在記憶體中只有一個副本，它當且僅當在類初次載入時會

c++中建構函式初始化的方法以及主要區別

一、我的問題是關於初始化C++類成員的。我見過許多這樣的程式碼： CSomeClass::CSomeClass() { x=0; y=1; } 而在別的什麼地方則寫成下面的樣子： CSomeClass::CSomeClass() : x(0), y(1) { } 我的一些程式設計師朋友說第

java中class的初始化順序

含有繼承的類的初始化順序：父類的靜態變數->父類的靜態塊->子類靜態變數->子類靜態初始化塊->父類變數->父類初始化塊->父類的建構函式->子類的變數->子類初始化塊->子類建構函式;(變數和初始化塊之間的先後順序根據類

C++成員變數的初始化順序問題

問題來源： 由於面試題中，考官出了一道簡單的程式輸出結果值的題：如下， class A { private: int n1; int n2; public: A():n2(0),n1(n2+2){} void Print(){ cout <<

C++類成員變數初始化順序問題

今天在看劍指offer這本書時，看待一個簡單的舉例，說應聘C++崗位的不知道成員變數初始化順序！我很驚訝，因為我也不知道，所以就看上網查了一下，看到了一個部落格（）以及其中的內容，現在將我的學習過程分

Java 物件初始化順序 執行順序

先看一道Java面試題： 求這段程式的輸出。 解答此題關鍵在於理解和掌握類的載入過程以及子類繼承父類後，重寫方法的呼叫問題： 從程式的執行順序去解答： 1.編譯；當這個類被編譯通知後，會在相應的

java 建立物件的四種方式、java物件初始化順序

java建立物件的幾種方式： (1) 用new語句建立物件，這是最常見的建立物件的方法。 (2) 運用反射手段,呼叫java.lang.Class或者java.lang.reflect.Const

C++中建構函式初始化列表為什麼會比建構函式中賦值要高效

Test { Test(test& t1) { this->t=t1; } private: test t; } 相信很多人跟我一樣，非常困惑為什麼Test構造時會先呼叫test的建構函式，再呼叫test類的賦值操作符。那是因為賦值操作符不能產生新的物件，Te