C++

X分鐘速成Y

其中 Y=c++

源代碼下載：?learncpp-cn.cpp

C++是一種系統(tǒng)編程語言。用它的發(fā)明者，?Bjarne Stroustrup的話來說，C++的設(shè)計(jì)目標(biāo)是：

• 成為“更好的C語言”
• 支持?jǐn)?shù)據(jù)的抽象與封裝
• 支持面向?qū)ο缶幊?/li>
• 支持泛型編程

C++提供了對(duì)硬件的緊密控制（正如C語言一樣）， 能夠編譯為機(jī)器語言，由處理器直接執(zhí)行。 與此同時(shí)，它也提供了泛型、異常和類等高層功能。 雖然C++的語法可能比某些出現(xiàn)較晚的語言更復(fù)雜，它仍然得到了人們的青睞—— 功能與速度的平衡使C++成為了目前應(yīng)用最廣泛的系統(tǒng)編程語言之一。

////////////////
// 與C語言的比較
////////////////

// C++_幾乎_是C語言的一個(gè)超集，它與C語言的基本語法有許多相同之處，
// 例如變量和函數(shù)的聲明，原生數(shù)據(jù)類型等等。

// 和C語言一樣，在C++中，你的程序會(huì)從main()開始執(zhí)行，
// 該函數(shù)的返回值應(yīng)當(dāng)為int型，這個(gè)返回值會(huì)作為程序的退出狀態(tài)值。
// 不過，大多數(shù)的編譯器（gcc，clang等）也接受 void main() 的函數(shù)原型。
// （參見 http://en.wikipedia.org/wiki/Exit_status 來獲取更多信息）
int main(int argc, char** argv)
{
    // 和C語言一樣，命令行參數(shù)通過argc和argv傳遞。
    // argc代表命令行參數(shù)的數(shù)量，
    // 而argv是一個(gè)包含“C語言風(fēng)格字符串”（char *）的數(shù)組，
    // 其中每個(gè)字符串代表一個(gè)命令行參數(shù)的內(nèi)容，
    // 首個(gè)命令行參數(shù)是調(diào)用該程序時(shí)所使用的名稱。
    // 如果你不關(guān)心命令行參數(shù)的值，argc和argv可以被忽略。
    // 此時(shí)，你可以用int main()作為函數(shù)原型。

    // 退出狀態(tài)值為0時(shí)，表示程序執(zhí)行成功
    return 0;
}

// 然而，C++和C語言也有一些區(qū)別：

// 在C++中，字符字面量的大小是一個(gè)字節(jié)。
sizeof('c') == 1

// 在C語言中，字符字面量的大小與int相同。
sizeof('c') == sizeof(10)

// C++的函數(shù)原型與函數(shù)定義是嚴(yán)格匹配的
void func(); // 這個(gè)函數(shù)不能接受任何參數(shù)

// 而在C語言中
void func(); // 這個(gè)函數(shù)能接受任意數(shù)量的參數(shù)

// 在C++中，用nullptr代替C語言中的NULL
int* ip = nullptr;

// C++也可以使用C語言的標(biāo)準(zhǔn)頭文件，
// 但是需要加上前綴“c”并去掉末尾的“.h”。
#include <cstdio>

int main()
{
    printf("Hello, world!\n");
    return 0;
}

///////////
// 函數(shù)重載
///////////

// C++支持函數(shù)重載，你可以定義一組名稱相同而參數(shù)不同的函數(shù)。

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)
}

///////////////////
// 函數(shù)參數(shù)的默認(rèn)值
///////////////////

// 你可以為函數(shù)的參數(shù)指定默認(rèn)值，
// 它們將會(huì)在調(diào)用者沒有提供相應(yīng)參數(shù)時(shí)被使用。

void doSomethingWithInts(int a = 1, int b = 4)
{
    // 對(duì)兩個(gè)參數(shù)進(jìn)行一些操作
}

int main()
{
    doSomethingWithInts();      // a = 1,  b = 4
    doSomethingWithInts(20);    // a = 20, b = 4
    doSomethingWithInts(20, 5); // a = 20, b = 5
}

// 默認(rèn)參數(shù)必須放在所有的常規(guī)參數(shù)之后。

void invalidDeclaration(int a = 1, int b) // 這是錯(cuò)誤的！
{
}

///////////
// 命名空間
///////////

// 命名空間為變量、函數(shù)和其他聲明提供了分離的的作用域。
// 命名空間可以嵌套使用。

namespace First {
    namespace Nested {
        void foo()
        {
            printf("This is First::Nested::foo\n");
        }
    } // 結(jié)束嵌套的命名空間Nested
} // 結(jié)束命名空間First

namespace Second {
    void foo()
    {
        printf("This is Second::foo\n")
    }
}

void foo()
{
    printf("This is global foo\n");
}

int main()
{
    // 如果沒有特別指定，就從“Second”中取得所需的內(nèi)容。
    using namespace Second;

    foo(); // 顯示“This is Second::foo”
    First::Nested::foo(); // 顯示“This is First::Nested::foo”
    ::foo(); // 顯示“This is global foo”
}

////////////
// 輸入/輸出
////////////

// C++使用“流”來輸入輸出。<<是流的插入運(yùn)算符，>>是流提取運(yùn)算符。
// cin、cout、和cerr分別代表
// stdin（標(biāo)準(zhǔn)輸入）、stdout（標(biāo)準(zhǔn)輸出）和stderr（標(biāo)準(zhǔn)錯(cuò)誤）。

#include <iostream> // 引入包含輸入/輸出流的頭文件

using namespace std; // 輸入輸出流在std命名空間（也就是標(biāo)準(zhǔn)庫）中。

int main()
{
   int myInt;

   // 在標(biāo)準(zhǔn)輸出（終端/顯示器）中顯示
   cout << "Enter your favorite number:\n";
   // 從標(biāo)準(zhǔn)輸入（鍵盤）獲得一個(gè)值
   cin >> myInt;

   // cout也提供了格式化功能
   cout << "Your favorite number is " << myInt << "\n";
   // 顯示“Your favorite number is <myInt>”

    cerr << "Used for error messages";
}

/////////
// 字符串
/////////

// C++中的字符串是對(duì)象，它們有很多成員函數(shù)
#include <string>

using namespace std; // 字符串也在std命名空間（標(biāo)準(zhǔn)庫）中。

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++還提供了_引用_。
// 引用是一種特殊的指針類型，一旦被定義就不能重新賦值，并且不能被設(shè)置為空值。
// 使用引用時(shí)的語法與原變量相同：
// 也就是說，對(duì)引用類型進(jìn)行解引用時(shí)，不需要使用*；
// 賦值時(shí)也不需要用&來取地址。

using namespace std;

string foo = "I am foo";
string bar = "I am bar";

string& fooRef = foo; // 建立了一個(gè)對(duì)foo的引用。
fooRef += ". Hi!"; // 通過引用來修改foo的值
cout << fooRef; // "I am foo. Hi!"

// 這句話的并不會(huì)改變fooRef的指向，其效果與“foo = bar”相同。
// 也就是說，在執(zhí)行這條語句之后，foo == "I am bar"。
fooRef = bar;

const string& barRef = bar; // 建立指向bar的常量引用。
// 和C語言中一樣，（指針和引用）聲明為常量時(shí)，對(duì)應(yīng)的值不能被修改。
barRef += ". Hi!"; // 這是錯(cuò)誤的，不能修改一個(gè)常量引用的值。

///////////////////
// 類與面向?qū)ο缶幊?///////////////////

// 有關(guān)類的第一個(gè)示例
#include <iostream>

// 聲明一個(gè)類。
// 類通常在頭文件（.h或.hpp）中聲明。
class Dog {
    // 成員變量和成員函數(shù)默認(rèn)情況下是私有（private）的。
    std::string name;
    int weight;

// 在這個(gè)標(biāo)簽之后，所有聲明都是公有（public）的，
// 直到重新指定“private:”（私有繼承）或“protected:”（保護(hù)繼承）為止
public:

    // 默認(rèn)的構(gòu)造器
    Dog();

    // 這里是成員函數(shù)聲明的一個(gè)例子。
    // 可以注意到，我們?cè)诖颂幨褂昧藄td::string，而不是using namespace std
    // 語句using namespace絕不應(yīng)當(dāng)出現(xiàn)在頭文件當(dāng)中。
    void setName(const std::string& dogsName);

    void setWeight(int dogsWeight);

    // 如果一個(gè)函數(shù)不對(duì)對(duì)象的狀態(tài)進(jìn)行修改，
    // 應(yīng)當(dāng)在聲明中加上const。
    // 這樣，你就可以對(duì)一個(gè)以常量方式引用的對(duì)象執(zhí)行該操作。
    // 同時(shí)可以注意到，當(dāng)父類的成員函數(shù)需要被子類重寫時(shí)，
    // 父類中的函數(shù)必須被顯式聲明為_虛函數(shù)（virtual）_。
    // 考慮到性能方面的因素，函數(shù)默認(rèn)情況下不會(huì)被聲明為虛函數(shù)。
    virtual void print() const;

    // 函數(shù)也可以在class body內(nèi)部定義。
    // 這樣定義的函數(shù)會(huì)自動(dòng)成為內(nèi)聯(lián)函數(shù)。
    void bark() const { std::cout << name << " barks!\n" }

    // 除了構(gòu)造器以外，C++還提供了析構(gòu)器。
    // 當(dāng)一個(gè)對(duì)象被刪除或者脫離其定義域時(shí)，它的析構(gòu)函數(shù)會(huì)被調(diào)用。
    // 這使得RAII這樣的強(qiáng)大范式（參見下文）成為可能。
    // 為了衍生出子類來，基類的析構(gòu)函數(shù)必須定義為虛函數(shù)。
    virtual ~Dog();

}; // 在類的定義之后，要加一個(gè)分號(hào)

// 類的成員函數(shù)通常在.cpp文件中實(shí)現(xiàn)。
void Dog::Dog()
{
    std::cout << "A dog has been constructed\n";
}

// 對(duì)象（例如字符串）應(yīng)當(dāng)以引用的形式傳遞，
// 對(duì)于不需要修改的對(duì)象，最好使用常量引用。
void Dog::setName(const std::string& dogsName)
{
    name = dogsName;
}

void Dog::setWeight(int dogsWeight)
{
    weight = dogsWeight;
}

// 虛函數(shù)的virtual關(guān)鍵字只需要在聲明時(shí)使用，不需要在定義時(shí)重復(fù)
void Dog::print() const
{
    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
}

void Dog::~Dog()
{
    cout << "Goodbye " << name << "\n";
}

int main() {
    Dog myDog; // 此時(shí)顯示“A dog has been constructed”
    myDog.setName("Barkley");
    myDog.setWeight(10);
    myDog.printDog(); // 顯示“Dog is Barkley and weighs 10 kg”
    return 0;
} // 顯示“Goodbye Barkley”

// 繼承：

// 這個(gè)類繼承了Dog類中的公有（public）和保護(hù)（protected）對(duì)象
class OwnedDog : public Dog {

    void setOwner(const std::string& dogsOwner)

    // 重寫OwnedDogs類的print方法。
    // 如果你不熟悉子類多態(tài)的話，可以參考這個(gè)頁面中的概述：
    // http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B

    // override關(guān)鍵字是可選的，它確保你所重寫的是基類中的方法。
    void print() const override;

private:
    std::string owner;
};

// 與此同時(shí)，在對(duì)應(yīng)的.cpp文件里：

void OwnedDog::setOwner(const std::string& dogsOwner)
{
    owner = dogsOwner;
}

void OwnedDog::print() const
{
    Dog::print(); // 調(diào)用基類Dog中的print方法
    // "Dog is <name> and weights <weight>"

    std::cout << "Dog is owned by " << owner << "\n";
    // "Dog is owned by <owner>"
}

/////////////////////
// 初始化與運(yùn)算符重載
/////////////////////

// 在C++中，通過定義一些特殊名稱的函數(shù)，
// 你可以重載+、-、*、/等運(yùn)算符的行為。
// 當(dāng)運(yùn)算符被使用時(shí)，這些特殊函數(shù)會(huì)被調(diào)用，從而實(shí)現(xiàn)運(yùn)算符重載。

#include <iostream>
using namespace std;

class Point {
public:
    // 可以以這樣的方式為成員變量設(shè)置默認(rèn)值。
    double x = 0;
    double y = 0;

    // 定義一個(gè)默認(rèn)的構(gòu)造器。
    // 除了將Point初始化為(0, 0)以外，這個(gè)函數(shù)什么都不做。
    Point() { };

    // 下面使用的語法稱為初始化列表，
    // 這是初始化類中成員變量的正確方式。
    Point (double a, double b) :
        x(a),
        y(b)
    { /* 除了初始化成員變量外，什么都不做 */ }

    // 重載 + 運(yùn)算符
    Point operator+(const Point& rhs) const;

    // 重載 += 運(yùn)算符
    Point& operator+=(const Point& rhs);

    // 增加 - 和 -= 運(yùn)算符也是有意義的，但這里不再贅述。
};

Point Point::operator+(const Point& rhs) const
{
    // 創(chuàng)建一個(gè)新的點(diǎn)，
    // 其橫縱坐標(biāo)分別為這個(gè)點(diǎn)與另一點(diǎn)在對(duì)應(yīng)方向上的坐標(biāo)之和。
    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類型的運(yùn)算符“+”
    // 調(diào)用up（Point類型）的“+”方法，并以right作為函數(shù)的參數(shù)
    Point result = up + right;
    // 顯示“Result is upright (1,1)”
    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
    return 0;
}

///////////
// 異常處理
///////////

// 標(biāo)準(zhǔn)庫中提供了一些基本的異常類型
// （參見http://en.cppreference.com/w/cpp/error/exception）
// 但是，其他任何類型也可以作為一個(gè)異常被拋出
#include <exception>

// 在_try_代碼塊中拋出的異常可以被隨后的_catch_捕獲。
try {
    // 不要用 _new_關(guān)鍵字在堆上為異常分配空間。
    throw std::exception("A problem occurred");
}
// 如果拋出的異常是一個(gè)對(duì)象，可以用常量引用來捕獲它
catch (const std::exception& ex)
{
  std::cout << ex.what();
// 捕獲尚未被_catch_處理的所有錯(cuò)誤
} catch (...)
{
    std::cout << "Unknown exception caught";
    throw; // 重新拋出異常
}

///////
// RAII
///////

// RAII指的是“資源獲取就是初始化”（Resource Allocation Is Initialization），
// 它被視作C++中最強(qiáng)大的編程范式之一。
// 簡單說來，它指的是，用構(gòu)造函數(shù)來獲取一個(gè)對(duì)象的資源，
// 相應(yīng)的，借助析構(gòu)函數(shù)來釋放對(duì)象的資源。

// 為了理解這一范式的用處，讓我們考慮某個(gè)函數(shù)使用文件句柄時(shí)的情況：
void doSomethingWithAFile(const char* filename)
{
    // 首先，讓我們假設(shè)一切都會(huì)順利進(jìn)行。

    FILE* fh = fopen(filename, "r"); // 以只讀模式打開文件

    doSomethingWithTheFile(fh);
    doSomethingElseWithIt(fh);

    fclose(fh); // 關(guān)閉文件句柄
}

// 不幸的是，隨著錯(cuò)誤處理機(jī)制的引入，事情會(huì)變得復(fù)雜。
// 假設(shè)fopen函數(shù)有可能執(zhí)行失敗，
// 而doSomethingWithTheFile和doSomethingElseWithIt會(huì)在失敗時(shí)返回錯(cuò)誤代碼。
// （雖然異常是C++中處理錯(cuò)誤的推薦方式，
// 但是某些程序員，尤其是有C語言背景的，并不認(rèn)可異常捕獲機(jī)制的作用）。
// 現(xiàn)在，我們必須檢查每個(gè)函數(shù)調(diào)用是否成功執(zhí)行，并在問題發(fā)生的時(shí)候關(guān)閉文件句柄。
bool doSomethingWithAFile(const char* filename)
{
    FILE* fh = fopen(filename, "r"); // 以只讀模式打開文件
    if (fh == nullptr) // 當(dāng)執(zhí)行失敗是，返回的指針是nullptr
        return false; // 向調(diào)用者匯報(bào)錯(cuò)誤

    // 假設(shè)每個(gè)函數(shù)會(huì)在執(zhí)行失敗時(shí)返回false
    if (!doSomethingWithTheFile(fh)) {
        fclose(fh); // 關(guān)閉文件句柄，避免造成內(nèi)存泄漏。
        return false; // 反饋錯(cuò)誤
    }
    if (!doSomethingElseWithIt(fh)) {
        fclose(fh); // 關(guān)閉文件句柄
        return false; // 反饋錯(cuò)誤
    }

    fclose(fh); // 關(guān)閉文件句柄
    return true; // 指示函數(shù)已成功執(zhí)行
}

// C語言的程序員通常會(huì)借助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); // 關(guān)閉文件
    return true; // 執(zhí)行成功

failure:
    fclose(fh);
    return false; // 反饋錯(cuò)誤
}

// 如果用異常捕獲機(jī)制來指示錯(cuò)誤的話，
// 代碼會(huì)變得清晰一些，但是仍然有優(yōu)化的余地。
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); // 保證出錯(cuò)的時(shí)候文件被正確關(guān)閉
        throw; // 之后，重新拋出這個(gè)異常
    }

    fclose(fh); // 關(guān)閉文件
    // 所有工作順利完成
}

// 相比之下，使用C++中的文件流類（fstream）時(shí)，
// fstream會(huì)利用自己的析構(gòu)器來關(guān)閉文件句柄。
// 只要離開了某一對(duì)象的定義域，它的析構(gòu)函數(shù)就會(huì)被自動(dòng)調(diào)用。
void doSomethingWithAFile(const std::string& filename)
{
    // ifstream是輸入文件流（input file stream）的簡稱
    std::ifstream fh(filename); // 打開一個(gè)文件

    // 對(duì)文件進(jìn)行一些操作
    doSomethingWithTheFile(fh);
    doSomethingElseWithIt(fh);

} // 文件已經(jīng)被析構(gòu)器自動(dòng)關(guān)閉

// 與上面幾種方式相比，這種方式有著_明顯_的優(yōu)勢(shì)：
// 1\. 無論發(fā)生了什么情況，資源（此例當(dāng)中是文件句柄）都會(huì)被正確關(guān)閉。
//    只要你正確使用了析構(gòu)器，就_不會(huì)_因?yàn)橥涥P(guān)閉句柄，造成資源的泄漏。
// 2\. 可以注意到，通過這種方式寫出來的代碼十分簡潔。
//    析構(gòu)器會(huì)在后臺(tái)關(guān)閉文件句柄，不再需要你來操心這些瑣事。
// 3\. 這種方式的代碼具有異常安全性。
//    無論在函數(shù)中的何處拋出異常，都不會(huì)阻礙對(duì)文件資源的釋放。

// 地道的C++代碼應(yīng)當(dāng)把RAII的使用擴(kuò)展到各種類型的資源上，包括：
// - 用unique_ptr和shared_ptr管理的內(nèi)存
// - 各種數(shù)據(jù)容器，例如標(biāo)準(zhǔn)庫中的鏈表、向量（容量自動(dòng)擴(kuò)展的數(shù)組）、散列表等；
//   當(dāng)它們脫離作用域時(shí)，析構(gòu)器會(huì)自動(dòng)釋放其中儲(chǔ)存的內(nèi)容。
// - 用lock_guard和unique_lock實(shí)現(xiàn)的互斥

擴(kuò)展閱讀：

http://cppreference.com/w/cpp?提供了最新的語法參考。

可以在?http://cplusplus.com?找到一些補(bǔ)充資料。