條款 01：視C++為一個語言聯(lián)邦

• C++的次語言：

  • C
  • Object-Oriented C++
  • Template C++
  • STL

• C++的編譯流程：
  C++代碼的編譯流程通常包括了多個階段，從源代碼到可執(zhí)行程序的生成。下面是一個簡要的C++代碼編譯流程的概述：

  1. 預處理（Preprocessing）：
     - 在這個階段，編譯器會處理所有的預處理指令，例如 `#include`、`#define` 等，以及刪除注釋。
     - 預處理指令的處理會生成一個經(jīng)過預處理的源代碼文件。

  2. 編譯（Compilation）：
     - 經(jīng)過預處理的源代碼會被編譯器轉換為匯編語言代碼（通常是中間表示形式）。
     - 編譯階段主要負責檢查語法錯誤和類型錯誤，并生成對應的中間表示文件。

  3. 匯編（Assembly）：
     - 在這個階段，匯編器將中間表示的代碼轉換為機器代碼，生成目標文件（通常是以 `.obj` 或 `.o` 為擴展名）。
     - 目標文件包含了計算機可執(zhí)行的二進制代碼和相關的元信息。

  4. 鏈接（Linking）：
     - 當你的程序使用了多個源文件或庫文件時，這些目標文件需要被鏈接在一起，生成最終的可執(zhí)行程序。
     - 鏈接器會解決函數(shù)調用、變量引用等，并將不同目標文件中的代碼和數(shù)據(jù)合并。
     - 最終的可執(zhí)行文件就是由鏈接器生成的。

  5. 加載（Loading）（可選）：
     - 如果你的操作系統(tǒng)需要，可執(zhí)行文件會被加載到內(nèi)存中，準備運行。
     - 這一步驟通常由操作系統(tǒng)完成。

  6. 運行（Execution）：
     - 可執(zhí)行程序在內(nèi)存中運行，執(zhí)行其中的代碼，產(chǎn)生相應的計算結果。

需要注意的是，這個流程可能在不同的編譯器和操作系統(tǒng)上有所不同。另外，現(xiàn)代的編譯器和開發(fā)環(huán)境通常會在這些階段中進行優(yōu)化，以提高代碼的性能和效率。

條款 02：盡量以const, enum, inline替換 #define

• #define是一個預處理指令，用于創(chuàng)建一個簡單的宏定義。它允許你在代碼中為一個特定的標識符（通常是一個變量名或常量，通常大寫）定義一個文本替換。當代碼被編譯前的預處理階段處理時，所有使用這個宏定義的地方都會被替換為指定的文本。
  缺點： 可能導致代碼可讀性下降、類型不匹配的問題、難以調試等。在現(xiàn)代C++中，傾向于使用類型安全的常量、枚舉、內(nèi)聯(lián)函數(shù)以及更高級的抽象來取代宏，以提高代碼的可維護性和可讀性。

#define PI 3.14159

• constC++ 中的“類專屬常量”（Class-specific Constants）通常是指在類內(nèi)部定義的常量。這些常量在類的作用域內(nèi)可見，只能通過類名訪問，而不能通過類的對象訪問。它們可以在類的任何成員函數(shù)中使用，無需實例化對象。
  通常情況下，類專屬常量會使用 static 關鍵字來定義，因為它們屬于類而不是類的實例。定義為 static 的常量將在所有類的實例之間共享，且只存在一份副本，可以節(jié)省內(nèi)存。

#include <iostream>
class MyClass {
public:
    static const int classConstant = 42; // 類專屬常量
    static const double pi; // 聲明，定義在類外部
    void printClassConstant() {
        std::cout << "Class constant: " << classConstant << std::endl;
    }
};
const double MyClass::pi = 3.1415926; // 在類外部定義類專屬常量
int main() {
    MyClass obj;
    obj.printClassConstant(); // 調用類專屬常量的成員函數(shù)
    std::cout << "Pi: " << MyClass::pi << std::endl; // 通過類名訪問類專屬常量
    return 0;
}

• enum在 C++ 中，非靜態(tài)成員變量（例如 Array）不能使用類的靜態(tài)成員變量（例如 ConstNumber）作為數(shù)組大小。在編譯時，數(shù)組大小必須是一個在編譯期就可以確定的常量表達式。

//錯誤的，ConstNumber 雖然是類的靜態(tài)常量，但是它在編譯期是無法確定的，因此不能用作數(shù)組大小。
class ANonDefine
{
public:
	static const int ConstNumber;
	 int Array[ConstNumber];
};

解決方法：

在ConstNumber聲明時就賦值。

使用enum

class ANonDefine
{
public:
	enum {ArraySize=5};
	int Array[ArraySize];
};

• inline宏函數(shù)容易出錯，可以使用inline代替

#include <iostream>
#define MAX_MACRO(a, b) ((a) >= (b) ? (a) : (b))
inline int max_inline(int a, int b) {
    return (a >= b) ? a : b;
}
int main() {
    int x = 5, y = 6;
    int result_macro = MAX_MACRO(++x, y); // 使用宏，產(chǎn)生不同的結果
    x = 5; y = 6; // 正確的變量賦值
    int result_inline = max_inline(++x, y); // 使用內(nèi)聯(lián)函數(shù)，產(chǎn)生不同的結果
    std::cout << "Macro result: " << result_macro << std::endl; //7
    std::cout << "Inline result: " << result_inline << std::endl;//6
    system("pause");
    return 0;
}

條款 03：盡可能使用const

• const 是一個關鍵字，用于指定變量、函數(shù)參數(shù)、函數(shù)返回類型等為常量。const 關鍵字的使用可以在代碼中增加類型安全性，并幫助防止對變量進行意外的修改。

// const出現(xiàn)在*左邊，表示被指物是常量，出現(xiàn)在*右邊，表示指針自身是常量
const int x = 5;  // 聲明一個不可修改的整數(shù)常量
const int* ptr = &x;  // 聲明一個指向常量的指針，指針指向的常量不可修改
int const * ptr = &x;  // 聲明一個指向常量的指針，指針指向的常量不可修改
int y = 10;
int* const ptr = &y;  // 聲明一個指針常量，指針不可修改
const int* const ptr = &y;  // 指針及其指向的常量都不可修改

• stl 中的 conststl 的迭代器基礎是指針，所以迭代器的作用就像個T *指針。
  聲明迭代器為 const 就像 T * const。表示指針不改變，可以改內(nèi)容。
  如果希望迭代器所指的東西不可改變，const_iterator代替iterator，表示指針可變，不可修改內(nèi)容。

std::vector<int>Vector;
for(int i=0;i<10;++i)
{
    Vector.push_back(i);
}
const std::vector<int>::iterator Iterator=Vector.begin();
*Iterator=10;//所指物可以修改
//Iterator++;迭代器不可修改
std::vector<int>::const_iterator ConstIterator=Vector.begin();
//*ConstIterator=10;所指物不可修改
ConstIterator++;//指針可以修改
for (auto i=ConstIterator;i!=Vector.end();++i)
{
	FFunctionLibrary::Println(*i);
}

• const成員函數(shù)在成員函數(shù)聲明和定義的末尾，使用 const 關鍵字來表示這是一個常量成員函數(shù)。
  在常量成員函數(shù)中，不能修改類的非靜態(tài)成員變量，包括類的數(shù)據(jù)成員和普通成員函數(shù)。
  常量對象（通過 const 關鍵字聲明的對象）只能調用常量成員函數(shù)。非常量對象可以調用常量成員函數(shù)。
  const 成員函數(shù)的返回類型是否加上 const 關鍵字會影響返回值的常量性，如果 const 成員函數(shù)的返回類型不加上 const 關鍵字，那么返回的值被修改。如果 const 成員函數(shù)的返回類型加上 const 關鍵字，那么返回的值將被視為常量，不允許修改，只能讀取。
  C++允許在類中同時定義常量和非常量版本的同名函數(shù)，它們可以通過對象的常量性來區(qū)分。這被稱為函數(shù)的 const 重載。const 類對象調用 const 成員函數(shù)，non-const 類對象調用普通成員函數(shù)。

#include <iostream>
class MyClass {
public:
    void printValue() {
        std::cout << "Non-const function: " << value << std::endl;
    }
    void printValue() const {
        std::cout << "Const function: " << value << std::endl;
    }
    void setValue(int newValue) {
        value = newValue;
    }
private:
    int value = 0;
};
int main() {
    MyClass obj;
    const MyClass constObj;
    obj.setValue(42);
    obj.printValue();      // 調用非常量成員函數(shù)
    constObj.printValue(); // 調用常量成員函數(shù)
    return 0;
}

• mutablemutable 用于修飾類的非靜態(tài)成員變量，在常量成員函數(shù)內(nèi)部允許對這些變量進行修改，即使對象被標記為 const。
  使用 mutable 可以在常量成員函數(shù)中實現(xiàn)對某些狀態(tài)的修改，而不影響常量性的約束。

class MyClass {
public:
    int getValue() const; // 聲明常量成員函數(shù)
private:
    mutable int count;   // 聲明一個可變成員變量
};
int MyClass::getValue() const {
    // 在常量成員函數(shù)內(nèi)修改可變成員變量
    count++;

到此這篇關于Effective C++ 學習筆記的文章就介紹到這了,更多相關Effective C++內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論