前言

這是一篇C#開發重新學習C++的體驗文章。

作為一個C#開發為什麼要重新學習C++呢？因為在C#在很多業務場景需要呼叫一些C++編寫的COM元件，如果不瞭解C++，那麼，很容易註定是要被C++同事忽悠的。

我在和很多C++開發者溝通的時候，發現他們都有一個非常奇怪的特點，都很愛裝X，都覺得自己技術很好，還很愛瞧不起人；但如果多交流，會發現更奇怪的問題，他們幾乎都不懂程式碼設計，程式碼寫的也都很爛。

所以，這次重溫C++也是想了解下這種奇異現象的原因。

C++重溫

首先開啟VisualStudio，建立一個C++的Windows控制檯應用程式，如下圖：

圖中有四個檔案，系統預設為我打開了標頭檔案和原始檔的資料夾。

系統這麼做是有意義的，因為剛學習時，外部依賴項，可以暫時不用看，而資原始檔夾是空的，所以我們只專注這兩個資料夾就可以了。

作為一個C#開發，我對C++就是一知半解，上學學過的知識也都忘記的差不多了，不過，我知道程式入口是main函式，所以我在專案裡先找擁有main函式的檔案。

結果發現ConsoleTest.cpp 檔案裡有main函式，那麼，我就在這個檔案裡開始學習C++了，而且它的命名和我專案名也一樣，所以很確定，它就是系統為我建立的專案入口檔案。

然後我開啟ConsoleTest.cpp 檔案，定義一個字串hello world，準備在控制檯輸出一下，結果發現編譯器報錯。。。只好調查一下了。

調查後得知，原來，c++裡沒有string型別，想使用string型別，只能先引用string的標頭檔案，在引用名稱空間std，如下：

#include "pch.h" 
#include <string>
using namespace std;
int main()
{
	string str = "Hello World!\n"; 
}

標頭檔案

標頭檔案到底是什麼呢？

標頭檔案，簡單來說就是一部分寫在main函式上面的程式碼。

比如上面的程式碼，我們將其中的引用標頭檔案和使用名稱空間的程式碼提取出來，寫進pch.h標頭檔案；然後，我們得到程式碼如下圖：

pch.h標頭檔案：

ConsoleTest.cpp檔案：

也就是說，標頭檔案是用來提取.cpp檔案的程式碼的。

呃。。。好像標頭檔案很雞肋啊，一個檔案的程式碼為什麼要提取一部分公共的？寫一起不就好了！為什麼要搞個檔案來單獨做，多傻的行為啊！

好吧，一開始我也的確是這麼想的。

後來我發現，標頭檔案，原來並不是單純的提取程式碼，還是跨檔案呼叫的基礎。

也就是說，ConsoleTest.cpp檔案，想呼叫其他Cpp檔案的變數，必須通過標頭檔案來呼叫。

比如，我新建一個test.cpp和一個test.h檔案。

然後我在test.cpp中，定義變數test=100；如下：

#include "pch.h"
#include "test.h"
int test = 100;

接著我在test.h檔案中再宣告下test變數，並標記該變數為外部變數，如下。

extern int test;

現在，我在回到ConsoleTest.cpp檔案，引用test.h檔案；然後我就可以在ConsoleTest.cpp檔案中使用test.cpp中定義的test變量了，如下：

#include "pch.h" 
#include "test.h" 
int main()
{
	string str = "Hello World!\n"; 
	cout << test << endl;
}

如上述程式碼所示，我們成功的輸出了test變數，其值為100。

到此，我們應該瞭解到了，標頭檔案的主要作用應該是把被拆散的程式碼，扭到一起的紐帶。

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

PS：我在上面引用字串標頭檔案時，使用的引用方法是【#include <string>】；我發現，引用該標頭檔案時，並沒有加字尾.h；我把字尾.h加上後【#include <string.h>】，發現編譯依然可以通過。

簡單的調查後得知，【#include <string>】是C++的語法，【#include <string.h>】是語法。因為C++要包含所有C的語法，所以，該寫法也支援。

Cin與Cout

Cin與Cout是控制檯的輸入和輸出函式，我在測試時發現，使用Cin與Cout需要引用iostream標頭檔案【#include <iostream>】，同時也要使用名稱空間std。

#include <iostream>
using namespace std;

在上面，我們提到過，使用字串型別string時，需要引用標頭檔案string.h和使用名稱空間std，那麼現在使用Cout也要使用名稱空間std。這是為什麼呢？

只能推斷，兩個標頭檔案string.h和iostream.h在定義時，都定義在名稱空間std下了。而且，通過我後期使用，發現還有好多類和型別也定義在std下了。

對此，我只能說，好麻煩。。。首先，缺失基礎型別這種事，就很奇怪，其次不是一個頭檔案的東西，定義到一個名稱空間下，也容易讓人混亂。

不過，對於C++，這麼做好像已經是最優解了。

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

PS：Cin與Cout是控制檯的輸入和輸出函式，開始時，我也不太明白，為什麼使用這樣兩個不是單詞的東西來作為輸入輸出，後來，在調查資料時，才明白，原來這個倆名字要拆開來讀。

讀法應該是這樣的C&in和C&out，這樣我們就清晰明白的理解了該函數了。

define，typedef，指標，引用型別，const

define

首先說define，define在C++裡好像叫做巨集。就定義一個全域性的字串，然後再任何地方都可以替換，如下：

#include "pch.h" 
#include "test.h" 
#define ERROR 518
int defineTest()
{
	return ERROR;
}
int main()
{ 
	cout << defineTest() << endl;
} 

也就是說，define定義的巨集，在C++裡就是個【行走的字串】，在編譯時，該字串會被替換回最初定義的值。這。。。這簡直就是編譯器允許的bug。。。

不過，它當然也有好處，就是字串更容易記憶和理解。但是說實話，定義一個列舉一樣好記憶，而且適用場景更加豐富，所以，個人感覺這個功能是有點雞肋，不過C++好多程式碼都使用了巨集，所以還是需要了解起來。

typedef

typedef是一個別名定義器，用來給複雜的宣告，定義成簡潔的宣告。

struct kiba_Org {
	int id;
};
typedef struct kiba_new {
	int id;
} kiba;
int main()
{
	struct kiba_Org korg;
	korg.id = 518;
	kiba knew;
	knew.id = 520;
	cout << korg.id << endl;
	cout << knew.id << endl;
} 

如上述程式碼所示，我定義了一個結構體kiba_Org，如果我要用kiba_Org宣告一個變數，我需要這樣寫【struct kiba_Org korg】，必須多寫一個struct。

但我如果用typedef給【struct kiba_Org korg】定義一個別名kiba，那麼我就可以直接拿kiba宣告變量了。

呃。。。對此，我只能說，為什麼會這麼麻煩！！！

以為這就很麻煩了嗎？NO！！！還有更麻煩的。

比如，我想在我定義的結構體裡使用自身的型別，要怎麼定義呢？

因為在C++裡，變數定義必須按照先聲明後使用的【絕對順序】，那麼，在定義時就使用自身型別，編譯器會提示錯誤。

如果想要讓編譯器通過，就必須在使用前，先給自身型別定義個別名，這樣就可以在定義時使用自身型別了。

呃。。。好像有點繞，我們直接看程式碼。

typedef struct kibaSelf *kibaSelfCopy;
struct kibaSelf
{
	int id;
	kibaSelfCopy myself;
};
int main()
{
	kibaSelf ks;
	ks.id = 518;
	kibaSelf myself;
	myself.id = 520;
	ks.myself = &myself;
	cout << ks.id << endl;
	cout << ks.myself->id << endl; 
} 

如上述程式碼所示，我們在定義結構體之前，先給它定義了個別名。

那麼，變數定義不是必須按照先聲明後使用的【絕對順序】嗎？為什麼這裡，又在定義前，可以定義別名了呢？這不是矛盾了嗎？

不知道，反正，C++就是這樣。。。就這麼屌。。。

指標

指標在C++中，就是在變數前加個*號，下面我們定義個指標來看看。

int i = 518;
int *ipointer = &i;
int* ipointer2 = &i;
cout << "*ipointer" << *ipointer << "===ipointer" << ipointer << endl;

如上述程式碼所示，我們定義了倆指標，int *ipointer 和int* ipointer2。可以看到，我這倆指標的*一個靠近變數一個靠近宣告符int，但兩種寫法都正確，編譯器可以編譯通過。

呃。。。就是這麼屌，學起來就是這麼優雅。。。

接著，我們用取地址符號&，取出i變數的地址給指標，然後指標變數*ipointer中ipointer儲存的是i的地址，而*ipointer儲存的是518，如下圖：

那麼，我們明明是把i的地址給了變數*ipointer，為什麼*ipointer儲存的是518呢？

因為。。。就是這麼屌。。。

哈哈，不開玩笑了，我們先看這樣一段程式碼，就可以理解了。

int i = 518;
int *ipointer;
int* ipointer2;
ipointer = &i;
ipointer2 = &i;
cout << "*ipointer" << *ipointer << "===ipointer" << ipointer << endl;

如上述程式碼所示，我把宣告和賦值給分開了，這樣就形象和清晰了。

我們把i的地址給了指標（*ipointer）中的ipointer，所以ipointer存的就是i的地址，而*ipointer則是根據ipointer所儲存的地址找到對應的值。

那麼，int *ipointer = &i;這樣賦值是什麼鬼？這應該報錯啊，應該不允許把i的地址給*ipointer啊。

呃。。。還是那句話，就是這麼屌。。。

->

->這個符號大概是指標專用的。下面我們來看這樣一段程式碼來了解->。

kiba kinstance;
kiba *kpointer;
kpointer = &kinstance;
(*kpointer).id = 518;
kpointer->id = 518;
//*kpointer->id = 518;

首先我們定義一個kiba結構體的例項，定義定義一個kiba結構體的指標，並把kinstance的地址給該指標。

此時，如果我想為結構體kiba中的欄位id賦值，就需要這樣寫【(*kpointer).id = 518】。

我必須把*kpointer擴起來，才能點出它對應的欄位id，如果不擴起來編譯器會報錯。

這樣很麻煩，沒錯，按說，微軟應該在編譯器中解決這個問題，讓他*kpointer不用被擴起來就可以使用。

但很顯然，微軟沒這樣解決，編譯器給的答案是，我們省略寫*號，然後直接用儲存地址的kpointer來呼叫欄位，但呼叫欄位時，就不能再用點(.)了，而是改用->。

呃。。。解決的就是這麼優雅。。。沒毛病。。。

引用型別

我們先定義接受引用型別的函式，如下。

int usage(int &i) {
	i = 518;
	return i;
}
int main()
{
	int u = 100;
	usage(u);
	cout << "u" << u << endl; 
} 

如上述程式碼所示，u經過函式usage後，他的值被改變了。

如果我們刪除usage函式中變數i前面的&，那麼u的值就不會改變。

好了，那麼&符號不是我們剛才講的取地址嗎？怎麼到這裡又變成了引用符了呢？

還是那句話。。。就是這麼屌。。。

呃。。。還有更屌的。。。我們來引用個指標。

void usagePointer(kiba *&k, kiba &kiunew) {
	k = &kiunew;
	k->id = 518;
}
int main()
{
	kiba kiunew;
	kiba kiu;
	kiba *kiupointer;
	kiupointer = &kiu; 
	kiupointer->id = 100;
	kiunew.id = 101;
	cout << "kiupointer->id" << kiupointer->id << "===kiupointer" << kiupointer << endl;
	usagePointer(kiupointer, kiunew);
	cout << "kiupointer->id" << kiupointer->id << "===kiupointer" << kiupointer << endl;
}

如上述程式碼所示，我定義了兩個結構體變數kiunew，kiu，和一個指標*kiupointer，然後我把kiu的地址賦值給指標。

接著我把指標和kiunew一起傳送給函式usagePointer，在函式裡，我把指標的地址改成了kiunew的地址。

執行結果如下圖。

可以看到，指標地址已經改變了。

如果我刪除掉函式usagePointer中的【引用符&】(某些情況下也叫取地址符)。我們將得到如下結果。

我們從圖中發現，不僅地址沒改變，賦值也失敗了。

也就是說，如果我們不使用【引用符&】來傳遞指標，那麼指標就是隻讀的，無法修改。

另外，大家應該也注意到了，指標的引用傳遞時，【引用符&】是在*和變數之間的，如果*&k。而普通變數的引用型別傳遞時，【引用符&】是在變數前的，如&i。

呃。。。指標，就是這麼屌。。。

const

const是定義常量的，這裡就不多說了。下面說一下，在函式中使用const符號。。。沒錯，你沒看錯，就是在函式中使用const符號。

int constusage(const int i) { 
	return i;
}

如程式碼所示，我們在入參int i前面加上了const修飾，然後，我們得到這樣的效果。

i在函式constusage，無法被修改，一但賦值就報錯。

呃。。。基於C#，估計肯定不好理解這個const存在的意義了，因為如果不想改，就別改啊，標只讀這麼費勁幹什麼。。。

不過我們換位思考一下，C++中這麼多記憶體控制，確實很亂，有些時候加上const修飾，標記只讀，還是很有必要的。

PCH

在專案建立的時候，系統為我們建立了一個pch.h標頭檔案，並且，每個.cpp檔案都引用了這個標頭檔案【#include "pch.h"】。

開啟.pch發現，裡面是空程式碼，在等待我們填寫。

既然.pch沒有被使用，那麼將【#include "pch.h"】刪掉來簡化程式碼，刪除後，發現編譯器報錯了。

調查後發現，原來專案在建立的時候，為我們設定了一個屬性，如下圖。

如圖，系統我們建立的pch.h標頭檔案，被設定成了預編輯標頭檔案。

下面，我修改【預編譯頭】屬性，修改為不使用預編譯頭，然後我們再刪除【#include "pch.h"】引用，編譯器就不會報錯了。

那麼，為什麼建立檔案時，會給我們設定一個預編譯頭呢？微軟這麼做肯定是有目的。

我們通過名字，字面推測一下。

pch.h是預編譯頭，那麼它的對應英文，大概就是Precompile Header。即然叫做預編譯，那應該在正式編譯前，執行的編譯。

也就是，編譯時，檔案被分批編譯了，pch.h預編譯頭會被提前編譯，我們可以推斷，預編譯頭是用於提高編譯速度的。

類

C++是一個同時面向過程和麵向物件的程式語言，所以，C++裡也有類和物件的存在。

類的基礎定義就不多說了，都一樣。

不過在C++中，因為，引用困難的原因（上面已經描述了，只能引用其他.cpp檔案對應的標頭檔案，並且，.cpp實現的變數，還得在標頭檔案裡外部宣告一下），所以類的定義寫法也發生了改變。

C++中建立類，需要在標頭檔案中宣告函式，然後在.cpp檔案中，做函式實現。

但是這樣做，明顯是跨檔案宣告類了，但C++中又沒有類似partial關鍵字讓倆個檔案合併編譯，那麼怎麼辦呢？

微軟給出的解決方案是，在.Cpp檔案中提供一個類外部編寫函式的方法。

下面，我們簡單的建立一個類，在標頭檔案中宣告一些函式和一些外部變數，然後在.cpp檔案中實現這些函式和變數。

右鍵標頭檔案資料夾—>新增——>類，在類名處輸入classtest，如下圖。

然後我們會發現，系統為我們建立了倆檔案，一個.h標頭檔案和一個.cpp檔案，如下圖。

然後編寫程式碼如下：

classtest.h標頭檔案:

class classtest
{
public:
	int id;
	string name;
	classtest();
	~classtest();
	int excute(int id);
private:
	int number;
	int dosomething();
};

calsstest.cpp檔案：

#include "pch.h"
#include "classtest.h" 
classtest::classtest()
{
} 
classtest::~classtest()
{
}
int classtest::excute(int id)
{
	this->id = id;
	return this->id;
}
int classtest::dosomething()
{
	this->number = 520;
	return this->number;
}

呼叫測試程式碼如下：

#include "pch.h" 
#include "classtest.h" 
int main()
{
	classtest ct;
	ct.excute(518);
	classtest *ctPointer = new classtest;
	ctPointer->excute(520);
	cout << "ct.id" << ct.id << "===ctPointer" << ctPointer->id << endl;
}

結語

通過重溫，我得出如下結論。

一，C++並不是一門優雅的開發語言，他自身存在非常多的設定矛盾和混淆內容，因此，C++的學習和應用的難度遠大於C# ；其難學的原因是C++本身缺陷導致，而不是C++多麼難學。

二，指標是C++開發學習設計模式的攔路虎，用C++學習那傳說中的26種設計模式，還勉強可以；但，如果想學習MVVM,AOP等等這些的設計模式的話，C++的指標會讓C++開發付出更多的程式碼量，因此多數C++開發對設計模式理解水平很低也是可以理解的了。

三，通過學習和反思，發現，我曾經接觸的那些愛裝X的C++開發，確實是坐井觀天、夜郎自大，他們的編寫程式碼的思維邏輯，確確實實是被C++的缺陷給限制住了。

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

到此，我重溫C++的心路歷程就結束了。

程式碼已經傳到Github上了，歡迎大家下載。

Github地址：https://github.com/kiba518/C-ConsoleTest

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

注：此文章為原創，歡迎轉載，請在文章頁面明顯位置給出此文連結！
若您覺得這篇文章還不錯，請點選下方的【推薦】，非常感謝！