源代碼下載： learncpp-cn.cpp
C++是一種系統編程語言。用它的發明者， Bjarne Stroustrup的話來説，C++的設計目標是：
- 成為“更好的C語言”
- 支持數據的抽象與封裝
- 支持面向對象編程
- 支持泛型編程
C++提供了對硬件的緊密控制（正如C語言一樣）， 能夠編譯為機器語言，由處理器直接執行。 與此同時，它也提供了泛型、異常和類等高層功能。 雖然C++的語法可能比某些出現較晚的語言更復雜，它仍然得到了人們的青睞—— 功能與速度的平衡使C++成為了目前應用最廣泛的系統編程語言之一。
////////////////
// 與C語言的比較
////////////////
// C++_幾乎_是C語言的一個超集，它與C語言的基本語法有許多相同之處，
// 例如變量和函數的聲明，原生數據類型等等。
// 和C語言一樣，在C++中，你的程序會從main()開始執行，
// 該函數的返回值應當為int型，這個返回值會作為程序的退出狀態值。
// 不過，大多數的編譯器（gcc，clang等）也接受 void main() 的函數原型。
// （參見 http://en.wikipedia.org/wiki/Exit_status 來獲取更多信息）
int main(int argc, char** argv)
{
// 和C語言一樣，命令行參數通過argc和argv傳遞。
// argc代表命令行參數的數量，
// 而argv是一個包含“C語言風格字符串”（char *）的數組，
// 其中每個字符串代表一個命令行參數的內容，
// 首個命令行參數是調用該程序時所使用的名稱。
// 如果你不關心命令行參數的值，argc和argv可以被忽略。
// 此時，你可以用int main()作為函數原型。
// 退出狀態值為0時，表示程序執行成功
return 0;
}
// 然而，C++和C語言也有一些區別：
// 在C++中，字符字面量的大小是一個字節。
sizeof('c') == 1
// 在C語言中，字符字面量的大小與int相同。
sizeof('c') == sizeof(10)
// C++的函數原型與函數定義是嚴格匹配的
void func(); // 這個函數不能接受任何參數
// 而在C語言中
void func(); // 這個函數能接受任意數量的參數
// 在C++中，用nullptr代替C語言中的NULL
int* ip = nullptr;
// C++也可以使用C語言的標準頭文件，
// 但是需要加上前綴“c”並去掉末尾的“.h”。
#include <cstdio>
int main()
{
printf("Hello, world!\n");
return 0;
}
///////////
// 函數重載
///////////
// C++支持函數重載，你可以定義一組名稱相同而參數不同的函數。
void print(char const* myString)
{
printf("String %s\n", myString);
}
void print(int myInt)
{
printf("My int is %d", myInt);
}
int main()
{
print("Hello"); // 解析為 void print(const char*)
print(15); // 解析為 void print(int)
}
///////////////////
// 函數參數的默認值
///////////////////
// 你可以為函數的參數指定默認值，
// 它們將會在調用者沒有提供相應參數時被使用。
void doSomethingWithInts(int a = 1, int b = 4)
{
// 對兩個參數進行一些操作
}
int main()
{
doSomethingWithInts(); // a = 1, b = 4
doSomethingWithInts(20); // a = 20, b = 4
doSomethingWithInts(20, 5); // a = 20, b = 5
}
// 默認參數必須放在所有的常規參數之後。
void invalidDeclaration(int a = 1, int b) // 這是錯誤的！
{
}
///////////
// 命名空間
///////////
// 命名空間為變量、函數和其他聲明提供了分離的的作用域。
// 命名空間可以嵌套使用。
namespace First {
namespace Nested {
void foo()
{
printf("This is First::Nested::foo\n");
}
} // 結束嵌套的命名空間Nested
} // 結束命名空間First
namespace Second {
void foo()
{
printf("This is Second::foo\n")
}
}
void foo()
{
printf("This is global foo\n");
}
int main()
{
// 如果沒有特別指定，就從“Second”中取得所需的內容。
using namespace Second;
foo(); // 顯示“This is Second::foo”
First::Nested::foo(); // 顯示“This is First::Nested::foo”
::foo(); // 顯示“This is global foo”
}
////////////
// 輸入/輸出
////////////
// C++使用“流”來輸入輸出。<<是流的插入運算符，>>是流提取運算符。
// cin、cout、和cerr分別代表
// stdin（標準輸入）、stdout（標準輸出）和stderr（標準錯誤）。
#include <iostream> // 引入包含輸入/輸出流的頭文件
using namespace std; // 輸入輸出流在std命名空間（也就是標準庫）中。
int main()
{
int myInt;
// 在標準輸出（終端/顯示器）中顯示
cout << "Enter your favorite number:\n";
// 從標準輸入（鍵盤）獲得一個值
cin >> myInt;
// cout也提供了格式化功能
cout << "Your favorite number is " << myInt << "\n";
// 顯示“Your favorite number is <myInt>”
cerr << "Used for error messages";
}
/////////
// 字符串
/////////
// C++中的字符串是對象，它們有很多成員函數
#include <string>
using namespace std; // 字符串也在std命名空間（標準庫）中。
string myString = "Hello";
string myOtherString = " World";
// + 可以用於連接字符串。
cout << myString + myOtherString; // "Hello World"
cout << myString + " You"; // "Hello You"
// C++中的字符串是可變的，具有“值語義”。
myString.append(" Dog");
cout << myString; // "Hello Dog"
/////////////
// 引用
/////////////
// 除了支持C語言中的指針類型以外，C++還提供了_引用_。
// 引用是一種特殊的指針類型，一旦被定義就不能重新賦值，並且不能被設置為空值。
// 使用引用時的語法與原變量相同：
// 也就是説，對引用類型進行解引用時，不需要使用*；
// 賦值時也不需要用&來取地址。
using namespace std;
string foo = "I am foo";
string bar = "I am bar";
string& fooRef = foo; // 建立了一個對foo的引用。
fooRef += ". Hi!"; // 通過引用來修改foo的值
cout << fooRef; // "I am foo. Hi!"
// 這句話的並不會改變fooRef的指向，其效果與“foo = bar”相同。
// 也就是説，在執行這條語句之後，foo == "I am bar"。
fooRef = bar;
const string& barRef = bar; // 建立指向bar的常量引用。
// 和C語言中一樣，（指針和引用）聲明為常量時，對應的值不能被修改。
barRef += ". Hi!"; // 這是錯誤的，不能修改一個常量引用的值。
///////////////////
// 類與面向對象編程
///////////////////
// 有關類的第一個示例
#include <iostream>
// 聲明一個類。
// 類通常在頭文件（.h或.hpp）中聲明。
class Dog {
// 成員變量和成員函數默認情況下是私有（private）的。
std::string name;
int weight;
// 在這個標籤之後，所有聲明都是公有（public）的，
// 直到重新指定“private:”（私有繼承）或“protected:”（保護繼承）為止
public:
// 默認的構造器
Dog();
// 這裏是成員函數聲明的一個例子。
// 可以注意到，我們在此處使用了std::string，而不是using namespace std
// 語句using namespace絕不應當出現在頭文件當中。
void setName(const std::string& dogsName);
void setWeight(int dogsWeight);
// 如果一個函數不對對象的狀態進行修改，
// 應當在聲明中加上const。
// 這樣，你就可以對一個以常量方式引用的對象執行該操作。
// 同時可以注意到，當父類的成員函數需要被子類重寫時，
// 父類中的函數必須被顯式聲明為_虛函數（virtual）_。
// 考慮到性能方面的因素，函數默認情況下不會被聲明為虛函數。
virtual void print() const;
// 函數也可以在class body內部定義。
// 這樣定義的函數會自動成為內聯函數。
void bark() const { std::cout << name << " barks!\n" }
// 除了構造器以外，C++還提供了析構器。
// 當一個對象被刪除或者脱離其定義域時，它的析構函數會被調用。
// 這使得RAII這樣的強大範式（參見下文）成為可能。
// 為了衍生出子類來，基類的析構函數必須定義為虛函數。
virtual ~Dog();
}; // 在類的定義之後，要加一個分號
// 類的成員函數通常在.cpp文件中實現。
void Dog::Dog()
{
std::cout << "A dog has been constructed\n";
}
// 對象（例如字符串）應當以引用的形式傳遞，
// 對於不需要修改的對象，最好使用常量引用。
void Dog::setName(const std::string& dogsName)
{
name = dogsName;
}
void Dog::setWeight(int dogsWeight)
{
weight = dogsWeight;
}
// 虛函數的virtual關鍵字只需要在聲明時使用，不需要在定義時重複
void Dog::print() const
{
std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
}
void Dog::~Dog()
{
std::cout << "Goodbye " << name << "\n";
}
int main() {
Dog myDog; // 此時顯示“A dog has been constructed”
myDog.setName("Barkley");
myDog.setWeight(10);
myDog.print(); // 顯示“Dog is Barkley and weighs 10 kg”
return 0;
} // 顯示“Goodbye Barkley”
// 繼承：
// 這個類繼承了Dog類中的公有（public）和保護（protected）對象
class OwnedDog : public Dog {
void setOwner(const std::string& dogsOwner)
// 重寫OwnedDogs類的print方法。
// 如果你不熟悉子類多態的話，可以參考這個頁面中的概述：
// http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B
// override關鍵字是可選的，它確保你所重寫的是基類中的方法。
void print() const override;
private:
std::string owner;
};
// 與此同時，在對應的.cpp文件裏：
void OwnedDog::setOwner(const std::string& dogsOwner)
{
owner = dogsOwner;
}
void OwnedDog::print() const
{
Dog::print(); // 調用基類Dog中的print方法
// "Dog is <name> and weights <weight>"
std::cout << "Dog is owned by " << owner << "\n";
// "Dog is owned by <owner>"
}
/////////////////////
// 初始化與運算符重載
/////////////////////
// 在C++中，通過定義一些特殊名稱的函數，
// 你可以重載+、-、*、/等運算符的行為。
// 當運算符被使用時，這些特殊函數會被調用，從而實現運算符重載。
#include <iostream>
using namespace std;
class Point {
public:
// 可以以這樣的方式為成員變量設置默認值。
double x = 0;
double y = 0;
// 定義一個默認的構造器。
// 除了將Point初始化為(0, 0)以外，這個函數什麼都不做。
Point() { };
// 下面使用的語法稱為初始化列表，
// 這是初始化類中成員變量的正確方式。
Point (double a, double b) :
x(a),
y(b)
{ /* 除了初始化成員變量外，什麼都不做 */ }
// 重載 + 運算符
Point operator+(const Point& rhs) const;
// 重載 += 運算符
Point& operator+=(const Point& rhs);
// 增加 - 和 -= 運算符也是有意義的，但這裏不再贅述。
};
Point Point::operator+(const Point& rhs) const
{
// 創建一個新的點，
// 其橫縱座標分別為這個點與另一點在對應方向上的座標之和。
return Point(x + rhs.x, y + rhs.y);
}
Point& Point::operator+=(const Point& rhs)
{
x += rhs.x;
y += rhs.y;
return *this;
}
int main () {
Point up (0,1);
Point right (1,0);
// 這裏使用了Point類型的運算符“+”
// 調用up（Point類型）的“+”方法，並以right作為函數的參數
Point result = up + right;
// 顯示“Result is upright (1,1)”
cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
return 0;
}
///////////
// 異常處理
///////////
// 標準庫中提供了一些基本的異常類型
// （參見http://en.cppreference.com/w/cpp/error/exception）
// 但是，其他任何類型也可以作為一個異常被拋出
#include <exception>
// 在_try_代碼塊中拋出的異常可以被隨後的_catch_捕獲。
try {
// 不要用 _new_關鍵字在堆上為異常分配空間。
throw std::exception("A problem occurred");
}
// 如果拋出的異常是一個對象，可以用常量引用來捕獲它
catch (const std::exception& ex)
{
std::cout << ex.what();
// 捕獲尚未被_catch_處理的所有錯誤
} catch (...)
{
std::cout << "Unknown exception caught";
throw; // 重新拋出異常
}
///////
// RAII
///////
// RAII指的是“資源獲取就是初始化”（Resource Allocation Is Initialization），
// 它被視作C++中最強大的編程範式之一。
// 簡單説來，它指的是，用構造函數來獲取一個對象的資源，
// 相應的，藉助析構函數來釋放對象的資源。
// 為了理解這一範式的用處，讓我們考慮某個函數使用文件句柄時的情況：
void doSomethingWithAFile(const char* filename)
{
// 首先，讓我們假設一切都會順利進行。
FILE* fh = fopen(filename, "r"); // 以只讀模式打開文件
doSomethingWithTheFile(fh);
doSomethingElseWithIt(fh);
fclose(fh); // 關閉文件句柄
}
// 不幸的是，隨着錯誤處理機制的引入，事情會變得複雜。
// 假設fopen函數有可能執行失敗，
// 而doSomethingWithTheFile和doSomethingElseWithIt會在失敗時返回錯誤代碼。
// （雖然異常是C++中處理錯誤的推薦方式，
// 但是某些程序員，尤其是有C語言背景的，並不認可異常捕獲機制的作用）。
// 現在，我們必須檢查每個函數調用是否成功執行，並在問題發生的時候關閉文件句柄。
bool doSomethingWithAFile(const char* filename)
{
FILE* fh = fopen(filename, "r"); // 以只讀模式打開文件
if (fh == nullptr) // 當執行失敗是，返回的指針是nullptr
return false; // 向調用者彙報錯誤
// 假設每個函數會在執行失敗時返回false
if (!doSomethingWithTheFile(fh)) {
fclose(fh); // 關閉文件句柄，避免造成內存泄漏。
return false; // 反饋錯誤
}
if (!doSomethingElseWithIt(fh)) {
fclose(fh); // 關閉文件句柄
return false; // 反饋錯誤
}
fclose(fh); // 關閉文件句柄
return true; // 指示函數已成功執行
}
// C語言的程序員通常會藉助goto語句簡化上面的代碼：
bool doSomethingWithAFile(const char* filename)
{
FILE* fh = fopen(filename, "r");
if (fh == nullptr)
return false;
if (!doSomethingWithTheFile(fh))
goto failure;
if (!doSomethingElseWithIt(fh))
goto failure;
fclose(fh); // 關閉文件
return true; // 執行成功
failure:
fclose(fh);
return false; // 反饋錯誤
}
// 如果用異常捕獲機制來指示錯誤的話，
// 代碼會變得清晰一些，但是仍然有優化的餘地。
void doSomethingWithAFile(const char* filename)
{
FILE* fh = fopen(filename, "r"); // 以只讀模式打開文件
if (fh == nullptr)
throw std::exception("Could not open the file.");
try {
doSomethingWithTheFile(fh);
doSomethingElseWithIt(fh);
}
catch (...) {
fclose(fh); // 保證出錯的時候文件被正確關閉
throw; // 之後，重新拋出這個異常
}
fclose(fh); // 關閉文件
// 所有工作順利完成
}
// 相比之下，使用C++中的文件流類（fstream）時，
// fstream會利用自己的析構器來關閉文件句柄。
// 只要離開了某一對象的定義域，它的析構函數就會被自動調用。
void doSomethingWithAFile(const std::string& filename)
{
// ifstream是輸入文件流（input file stream）的簡稱
std::ifstream fh(filename); // 打開一個文件
// 對文件進行一些操作
doSomethingWithTheFile(fh);
doSomethingElseWithIt(fh);
} // 文件已經被析構器自動關閉
// 與上面幾種方式相比，這種方式有着_明顯_的優勢：
// 1. 無論發生了什麼情況，資源（此例當中是文件句柄）都會被正確關閉。
// 只要你正確使用了析構器，就_不會_因為忘記關閉句柄，造成資源的泄漏。
// 2. 可以注意到，通過這種方式寫出來的代碼十分簡潔。
// 析構器會在後台關閉文件句柄，不再需要你來操心這些瑣事。
// 3. 這種方式的代碼具有異常安全性。
// 無論在函數中的何處拋出異常，都不會阻礙對文件資源的釋放。
// 地道的C++代碼應當把RAII的使用擴展到各種類型的資源上，包括：
// - 用unique_ptr和shared_ptr管理的內存
// - 各種數據容器，例如標準庫中的鏈表、向量（容量自動擴展的數組）、散列表等；
// 當它們脱離作用域時，析構器會自動釋放其中儲存的內容。
// - 用lock_guard和unique_lock實現的互斥擴展閲讀：
- CPP Reference 提供了最新的語法參考。
- 可以在 CPlusPlus 找到一些補充資料。
- 可以在 [TheChernoProject - C ++](https://www.youtube.com/playl...）上找到涵蓋語言基礎和設置編碼環境的教程。
有建議？或者發現什麼錯誤？在Github上開一個issue，或者發起pull request！
原著Steven Basart，並由0個好心人修改。
Translated by: Arnie97
© 2022 Steven Basart, Matt Kline
本作品採用 CC BY-SA 3.0 協議進行許可。
