C++ 的 forward declaration

假設現在要在自己使用的函式庫裡面、使用一個別人寫好的函式庫的時候，通常會需要引用他提供的 header 檔案，然後才能使用他提供的物件、函式。這邊假設有一個函式庫提供的 header 長得像下面這樣：

#pragma once
// LibA.h
 
//#include "A01.h"
// ...
//#include "A09.h"
 
enum ErrorCode
{
  OK,
  Error1,
  Error2
};
 
class LibAObj
{
public:
  ErrorCode func()
  {
    return OK;
  }
  //...
};

他提供了一個類別 LibAObj 作為主要的操作對象，裡面有一個叫做 func() 的函式；另外，他也定義了 ErrorCode 這個列舉型別，來描述函示執行的結果。

而由於這個檔案是由別的開發者撰寫、提供的，考量到後續維護，可以先將這個 Lib.h 視為不可修改的檔案。

至於要使用它來開發的函式庫，一般可能會寫成下面的樣子：

#pragma once
// MyLib.h
#include "libA.h"
 
class MyLib
{
public:
  bool func()
  {
    if (mObj.func() == OK)
      return true;
    
    return false;
  }
 
protected:
  LibAObj mObj;
};

使用時，則是會是：

#include <iostream>
 
#include "MyLib.h"
 
int main()
{
  MyLib a;
  if (a.func())
    std::cout << "OK" << std::endl;
  else
    std::cout << "Error" << std::endl;
}

在一般狀況下，這樣大概都是沒問題的，使用者也不需要去碰到底層 libA 的東西。

但是，如果在應用程式端，又需要用到別的函式庫的時候…恩，就可能就會碰到命名衝突的問題了。

比如說，如果有的 libB.h 裡面，寫了：

// LibB.h
enum ErrorCode
{
  BOK
};

那如果同時 include MyLib.h 和 libB.h，就會出現 ErrorCode 被重複定義、而無法正確編譯的狀況了！而如果是有定義同名的巨集的時候，更是有可能會其他的問題產生。

此外，上面的寫法中，由於 MyLib.h 中會 include libA.h 這個 header、而 libA.h 裡面可能又 include 了更多的 header，這會導致在編譯應用程式的檔案時，編譯器只要遇到有 include MyLib.h 的檔案的時候，就需要去處理 libA.h 有引用到的 header，所以有可能會多花不少時間。

而要避免上面的問題呢，一個方法就是使用 forward declaration 的形式、來改寫 MyLib.h。

#pragma once
// MyLib.h
#include <memory>
 
class LibAObj; // Forward declaration
 
class MyLib
{
public:
  MyLib();
  ~MyLib();
 
  bool func();
 
protected:
  std::unique_ptr<LibAObj> mObj;
};

這邊修改的點包括了：

• 不在 header 檔中 include libA.h
• 針對 libA.h 需要使用的型別（libAObj）透過 forward declaration 宣告
• 使用 pointer 的形式取代 libAObj 的物件（這邊是用 smart point）
• 將會使用到 libAObj 的內容的部分都從 .h 移到 .cpp（包括 new 和 delete）

然後，對應的 MyLib.cpp 會變成下面的樣子：

// MyLib.cpp
#include "libA.h"
 
#include "MyLib.h"
 
MyLib::MyLib()
{
  mObj = std::make_unique<LibAObj>();
}
 
MyLib::~MyLib(){}
 
bool MyLib::func()
{
  if (mObj->func() == OK)
    return true;
 
  return false;
}

透過這樣的修改，和 libA.h 有關的東西，都會被藏在 MyLib.cpp 裡面，在編譯其他 include MyLib.h 的檔案的時候，都不會真的碰到和 libA.h 的內容，也就代表和 libA.h 有關的 header 只需要在編譯 MyLib.cpp 才需要處理。

所以如果在專案中有很多檔案有用到 MyLib.h 的時候，這樣的寫法是可以減少編譯時需要的時間的。

同時，由於 libA.h 內定義的東西，也都被藏在 MyLib.cpp 裡面，所以就算應用程式那邊還有 include LibB.h、也有同名的 ErrorCode 列舉型別，也不會造成命名的衝突。

另外，這邊為什麼 destructor 明明是空的，還是要寫在 MyLib.cpp 呢？
這是因為 std::unique_ptr<> 這類的 smart pointer 雖然可以自己釋放資源，但是在釋放的時候會需要完整的型別；而如果使用預設的解構子、或是把解構子寫在 header 的話，就會變成要 smart pointer 去刪除一個 incomplete type 的物件，所以會無法正確編譯。
而寫在 MyLib.cpp 中，他才能知道 LibAObj 的型別內容、並正確地刪除。