天天看點
傳回

#pragma once, extern

1,聲明一個變量，必須加關鍵字extern

2,沒有關鍵字extern，則就為變量的定義，無論這個變量定義時有沒有初始化

3,隻要定義變量時初始化了，即使前面加了關鍵字extern，也是定義，不是聲明。（不過隻有在函數體外時，才能夠在定義且初始化時，加上extern關鍵字，這是為了const變量設定的）

4,多檔案程式中，一個檔案含有變量的定義，另外一個檔案中含有變量的聲明，定義隻能有一次，聲明不限。

5,非const變量，定義時預設是加了extern的，即在函數體外定義變量時，預設加了extern，說明這是一個全局變量，可以被其他檔案通路（通路的前提是在這個檔案中做了聲明）。

   但是const變量，預設是不加extern的，也就是即使在函數體外全局作用域定義一個const變量，也隻能夠在定義的這個檔案通路，不能被其他檔案通路。要想被其他檔案通路，需要在定義const變量時，顯示的加上extern關鍵詞。　

    extern可以置于變量或者函數前，以标示變量或者函數的定義在别的檔案（當然也有可能定義就在本檔案中）中，提示編譯器遇到此變量和函數時在其他子產品中尋找其定義。

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    "#pragma once" make sure header file was included once in the cpp file when compiling, but extern make sure the varible is defined once when linking different cpp files.

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

C++程式設計語言從出現至今已經發展的越發成熟，逐漸成為了開發領域中一個重要的應用語言。今天大家可以從這篇文章中詳細了解到有關C++頭檔案的一些嵌套方法，進而讓大家更進一步的對這一語言有一個詳細的了解。

在實際程式設計中，不同的類一般是放在不同的互相獨立的C++頭檔案中的，這樣兩個類在互相引用時又會有不一樣的問題。重複編譯是問題出現的根本原因。為了保證頭文 件僅被編譯一次，在C++中常用的辦法是使用條件編譯指令。

     
  1.  Example：         
    2.       
  2.  animal.h          
    3.       
  3.  class animal          
    4.       
  4.  {          
    5.       
  5.  ......         
    6.       
  6.  };          
    7.       
  7.  animal.cpp          
    8.       
  8.  #include "animal.h"          
    9.       
  9.  #include <iostream.h>          
    10.       
  10.  ......         
    11.       
  11.  fish.h          
    12.       
  12.  #include "animal.h"          
    13.       
  13.  class fish         
    14.       
  14.  {          
    15.       
  15.  ......          
    16.       
  16.  };          
    17.       
  17.  fish.cpp          
    18.       
  18.  #include "fish.h"          
    19.       
  19.  #include <iostream.h>          
    20.       
  20.  ......         
    21.       
  21.  main.cpp          
    22.       
  22.  #include "animal.h"          
    23.       
  23.  #include "fish.h"          
    24.       
  24.  void main()          
    25.       
  25.  {          
    26.       
  26.  ......         
    27.       
  27.  }        
    28.

編譯檔案,會出現class type redefinition的錯誤

為什麼會出現類重複定義的錯誤呢？請讀者仔細檢視EX10.cpp檔案，在這個檔案中包含了animal.h和fish.h這兩個頭檔案。當編譯器編譯EX10.cpp檔案時，因為在檔案中包含了animal.h頭檔案，編譯器展開這個C++頭檔案，知道animal這個類定義了，接着展開fish.h 頭檔案，而在fish.h頭檔案中也包含了animal.h，再次展開animal.h，于是animal這個類就重複定義了。

要解決C++頭檔案重複包含的問題，可以使用條件預處理指令。修改後的頭檔案如下：

     
  1.  animal.h          
    2.       
  2.  #ifndef ANIMAL_H_H          
    3.       
  3.  #define ANIMAL_H_H          
    4.       
  4.  class animal          
    5.       
  5.  {          
    6.       
  6.  ......         
    7.       
  7.  };          
    8.       
  8.  #endif          
    9.       
  9.  fish.h          
    10.       
  10.  #include "animal.h"          
    11.       
  11.  #ifndef FISH_H_H          
    12.       
  12.  #define FISH_H_H          
    13.       
  13.  class fish         
    14.       
  14.  {          
    15.       
  15.  ......          
    16.       
  16.  };          
    17.       
  17.  #endif        
    18.

我們再看EX10.cpp的編譯過程。當編譯器展開animal.h頭檔案時，條件預處理指令判斷ANIMAL_H_H沒有定義，于是就定 義它，然後繼續執行，定義了animal這個類；接着展開fish.h頭檔案，而在fish.h頭檔案中也包含了animal.h，再次展開 animal.h，這個時候條件預處理指令發現ANIMAL_H_H已經定義，于是跳轉到#endif，執行結束。

但是不要以為使用了這種機制就全部搞定了，比如在以下的代碼中：

     
  1.  //檔案A.h中的代碼         
    2.       
  2.  #pragma once         
    3.       
  3.  #include "B.h"         
    4.       
  4.  class A         
    5.       
  5.  {         
    6.       
  6.  public:         
    7.       
  7.  B* b;         
    8.       
  8.  };         
    9.       
  9.  //檔案B.h中的代碼         
    10.       
  10.  #pragma once         
    11.       
  11.  #include "A.h"         
    12.       
  12.  class B         
    13.       
  13.  {         
    14.       
  14.  public:         
    15.       
  15.  A* a;         
    16.       
  16.  };        
    17.

這裡兩者都使用了指針成員，是以嵌套本身不會有什麼問題，在主函數前面使用#include "A.h"之後，主要編譯錯誤如下：

     
  1.  error C2501: 'A' : missing storage-class or type specifiers        
    2.

仍然是類型不能找到的錯誤。其實這裡仍然需要前置聲明。分别添加前置聲明之後，可以成功編譯了。代碼形式如下：

     
  1.  //檔案A.h中的代碼         
    2.       
  2.  #pragma once         
    3.       
  3.  #include "B.h"         
    4.       
  4.  class B;         
    5.       
  5.  class A         
    6.       
  6.  {         
    7.       
  7.  public:         
    8.       
  8.  B* b;         
    9.       
  9.  };         
    10.       
  10.  //檔案B.h中的代碼         
    11.       
  11.  #pragma once         
    12.       
  12.  #include "A.h"         
    13.       
  13.  class A;         
    14.       
  14.  class B         
    15.       
  15.  {         
    16.       
  16.  public:         
    17.       
  17.  A* a;         
    18.       
  18.  };        
    19.

這樣至少可以說明，C++頭檔案包含代替不了前置聲明。有的時候隻能依靠前置聲明來解決問題。我們還要思考一下，有了前置聲明的時候頭檔案包含還是必要的 嗎？我們嘗試去掉A.h和B.h中的#include行，發現沒有出現新的錯誤。那麼究竟什麼時候需要前置聲明，什麼時候需要頭檔案包含呢？

基礎知識 編譯器 語言 程式設計 header file class
上一篇: 【釘釘開放平台】錯誤分析：errcode“: 810003,“error_msg“: “審批流表單格式錯誤“
下一篇: 關于指針和多元數組的使用

繼續閱讀