learnxinyminutes-docs/zh-cn/c++-cn.html.markdown
2015-03-19 00:31:33 +08:00

18 KiB
Raw Blame History

language filename contributors translators lang
c++ learncpp.cpp
Steven Basart
http://github.com/xksteven
Matt Kline
https://github.com/mrkline
Arnie97
https://github.com/Arnie97
zh-cn

C++是一種系統編程語言。用它的發明者, Bjarne Stroustrup的話來說C++的設計目標是:

  • 成爲「更好的C語言」
  • 支持數據的抽象與封裝
  • 支持面向對象編程
  • 支持泛型編程

C++提供了對硬件的緊密控制正如C語言一樣 能夠編譯爲機器語言,由處理器直接執行。 與此同時,它也提供了泛型、異常和類等高層功能。 雖然C++的語法可能比某些出現較晚的語言更複雜,它仍然得到了人們的青睞—— 功能與速度的平衡使C++成爲了目前應用最廣泛的系統編程語言之一。

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

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

// 和C語言一樣在C++中你的程序會從main()開始執行,
// 該函數的返回值應當爲int型這個返回值會作爲程序的退出狀態值。
// 不過大多數的編譯器gccclang等也接受 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++支持函數重載【provided each function takes different parameters.】

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) // 這是錯誤的!
{
}


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

// 命名空間爲變量、函數和其他聲明提供了【separate】的作用域。
// 命名空間可以嵌套使用。

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()
{
    cout << "Goodbye " << name << "\n";
}

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()
{
    cout << "Goodbye " << name << "\n";
}

int main() {
    Dog myDog; // 此時顯示「A dog has been constructed」
    myDog.setName("Barkley");
    myDog.setWeight(10);
    myDog.printDog(); // 顯示「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://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping

    // 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++中,你可以重載+、-、*、/等運算符的行爲。
// 【This is done by defining a function
// which is called whenever the operator is used.

#include <iostream>
using namespace std;

class Point {
public:
    // 可以以這樣的方式爲成員變量設置默認值。
    double x = 0;
    double y = 0;

    // 【Define a default constructor which does nothing
    // but initialize the Point to the default value (0, 0)
    Point() { };

    // 【The following syntax is known as an initialization list
    // and is the proper way to initialize class member values
    Point (double a, double b) :
        x(a),
        y(b)
    { /* 【Do nothing except initialize the values */ }

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

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

    // 增加 - 和 -= 運算符也是有意義的,這裏不再贅述。
};

Point Point::operator+(const Point& rhs) const
{
    // 【Create a new point that is the sum of this one and rhs.
    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類型的運算符「+」
    // 調用upPoint類型的「+」方法並以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); // Close the file handle so it doesn't leak.
        return false; // 反饋錯誤
    }
    if (!doSomethingElseWithIt(fh)) {
        fclose(fh); // Close the file handle so it doesn't leak.
        return false; // 反饋錯誤
    }

    fclose(fh); // Close the file handle so it doesn't leak.
    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; // Then re-throw the exception.
    }

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

// 【Compare this to the use of C++'s file stream class (fstream)
// fstream利用自己的析構器來關閉文件句柄。
// 【Recall from above that destructors are automatically called
// whenver an object falls out of scope.
void doSomethingWithAFile(const std::string& filename)
{
    // ifstream是輸入文件流input file stream的簡稱
    std::ifstream fh(filename); // Open the file

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

} // 文件已經被析構器自動關閉

// 與上面幾種方式相比這種方式有着_明顯_的優勢
// 1. 無論發生了什麼情況,資源(此例當中是文件句柄)都會被正確關閉。
//    只要你正確使用了析構器就_不會_因爲忘記關閉句柄造成資源的泄漏。
// 2. 可以注意到,通過這種方式寫出來的代碼十分簡潔。
//    析構器會在後臺關閉文件句柄,不再需要你來操心這些瑣事。
// 3. 【The code is exception safe.
//    無論在函數中的何處拋出異常,都不會阻礙對文件資源的釋放。

// 地道的C++代碼應當把RAII的使用擴展到各種類型的資源上包括
// - 用unique_ptr和shared_ptr管理的內存
// - 各種數據容器,例如標準庫中的鏈表、向量(容量自動擴展的數組)、散列表等;
//   當它們脫離作用域時,析構器會自動釋放其中儲存的內容。
// - 用lock_guard和unique_lock實現的互斥

擴展閱讀:

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

可以在 http://cplusplus.com 找到一些補充資料。