C標準庫思維導圖、C++關鍵字概覽

1 C標準庫思維導圖

https://wwuhn.github.io/shared/C標準庫思維導圖.png

2 C++關鍵字概覽

https://wwuhn.github.io/shared/cppKeywords.html

1 asm

asm (assembly)

允許在 C++ 程序中嵌入彙編代碼。

<code>    int a=5;  
    int b=4;
    __asm
    {  
        mov eax, a  ;可以像這樣直接對eax賦值  
        mov ebx, b;  
        add eax, ebx 
        mov a, eax ;可以直接將eax的值賦給a  
    }
/<code>

2 auto

auto（自動，automatic）

① 是存儲類型標識符，表明變量"自動"具有本地範圍，塊範圍的變量聲明（如for循環體內的變量聲明）默認為auto存儲類型。（until C++11）

② 對於變量，指定將從其初始值自動推斷聲明的變量的類型。(since C++11)

③ 對於函數，指定將從其返回語句推導返回類型。(since C++14)

④ 對於非類型模板參數，指定將從參數派生類型。(since C++17)

3 bool

bool（布爾）

bool表示邏輯類型，其值可選為 true（真）或者 false（假）。C++ 中的 bool 類型可以和 int 混用，具體來說就是 0 代表 false，非 0 代表 true。bool 類型常用於條件判斷和函數返回值。

4 break

break（中斷、跳出）

用在switch語句或者循環語句中。程序遇到 break 後，即跳過該程序段，繼續後面的語句執行。

通常和if、case語句配合使用。

5 case

用於 switch 語句中，用於判斷不同的條件類型。

標籤語句，提供執行入口，符合條件時進入，直至break或default:或switch結束。

6 catch

catch 和 try 語句一起用於異常處理。在try中（包括其調用的函數）拋出異常，catch按拋出的數據類型匹配異常。

7 char

char（字符，character）

C++ 中的基本數據結構，其值一般為 0~255 的 int。這 256 個字符對應著 256 個 ASCII 碼。char 類型的數據需要用單引號 ' 括起來。

8 class

class（類）是 C++ 面向對象設計的基礎。① 使用 class 關鍵字聲明一個類。

② 用於聲明一個強類型的enum。(since C++11)

<code>enum class Color { red, green = 20, blue };/<code>

③ 在模板函數或模板類中，用來聲明一個類型參數，此時可用typename代替。

9 const

const（常量的，constant）

表示所修飾的對象或變量不能被改變，① 修飾函數時，該函數不能改變在該函數外面聲明的變量也不能調用任何非const函數。在函數的聲明與定義時都要加上const，放在函數參數列表的最後一個括號後。② 用 const 聲明一個變量，意味著該變量就是一個帶類型的常量，可以代替 #define，且比 #define 多一個類型信息，且它執行內鏈接，可放在頭文件中聲明；但在 C 中，其聲明則必須放在源文件（即 .C 文件）中，在 C 中 const 聲明一個變量，除了不能改變其值外，它仍是一具變量。如:

<code>const double pi(3.14159);
或 
const double pi = 3.14159;
/<code>

用於修飾指針時要考慮修飾的是指針本身還是指針所指向的內存單元：

<code>const int* p;       // 修飾int，表示不能用p更新其指向的內存單元
int const* p;       // 同上
int* const p;       // 修飾p，表示指針p本身是常量，不能被更新
                    // 區別其實就是以*為分隔，看const是在*前還在*後
const int* const p; // 綜合上述，兩者同為const
/<code>

10 const_cast

const_cast<type> (expression)/<type>

該運算符用來修改類型的 const 或 volatile 屬性。除了 const 或 volatile 修飾之外， type_to 和 expression 的類型是一樣的。常量指針被轉化成非常量指針，並且仍然指向原來的對象；常量引用被轉換成非常量引用，並且仍然指向原來的對象；常量對象被轉換成非常量對象。

<code>    int i = 3;                 // i is not declared const
    const int& rci = i; 
    const_cast(rci) = 4; // OK: modifies i
/<code>

11 continue

continue（繼續）

用於循環結構。它使程序跳過代碼段後部的部分，與 break 不同的是，continue 不是進入代碼段後的部分執行，而是重新開始新的循環。因而它是"繼續循環"之意，不是 break（跳出）。常和if語句配合使用。

12 default

default（默認、缺省）

① 用於 switch 語句。當 switch 所有的 case 都不滿足時，將進入 default 執行。default 只能放在 switch 語句所有的 case 之後，並且是可選的。

② explicitly-defaulted function definition: as an explicit instruction to the compiler to generate special member function(since C++11) or a comparison operator (since C++20) for a class.

13 delete

delete（刪除）

① 釋放程序動態申請的內存空間。delete 後面通常是一個指針或者數組 []，並且只能 delete 通過 new 關鍵字申請的指針，否則會發生段錯誤。

<code>Complex* pc = new Complex(1,2);
// ...
delete pc;
// 編譯器轉化為：
Complex::~Complex(pc); // ① 調用析構函數
operator delete(pc);   // ② 釋放內存，內部調用free(pc)
/<code>

② deleted functions (since C++11)

14 do

do-while是一類循環結構。與while循環不同，do-while循環保證至少要進入循環體一次。

15 double

double（雙精度）

C++ 中的基本數據類型，以雙精度形式存儲一個浮點數。（IEEE-754）

16 dynamic_cast

dynamic_cast（動態轉換），允許在運行時刻進行類型轉換，從而使程序能夠在一個類層次結構安全地轉換類型。dynamic_cast 提供了兩種轉換方式，把基類指針轉換成派生類指針，或者把指向基類的左值轉換成派生類的引用。

<code>struct V {
    virtual void f() {};  // must be polymorphic to use runtime-checked dynamic_cast
};
struct A : virtual V {};
struct B : virtual V {
  B(V* v, A* a) {
    // casts during construction (see the call in the constructor of D below)
    dynamic_cast(v); // well-defined: v of type V*, V base of B, results in B*
    dynamic_cast(a); // undefined behavior: a has type A*, A not a base of B
  }
};
/<code>

17 else

else 緊跟在 if 後面，用於對 if 不成立的情況的選擇。

else與if按最近原則匹配，if後儘量不要省略else，避免懸掛。

18 enum

enum（枚舉，enumeration）

對於一個整型變量，如果只有幾種有限的取值可能時，可以把這些值枚舉出來，並用符號常量代替之。

19 explicit

explicit（顯式的）

禁止單參數構造函數被用於自動型別轉換，其中比較典型的例子就是容器類型。在這種類型的構造函數中你可以將初始長度作為參數傳遞給構造函數。

20 export

① 為了訪問其他編譯單元（如另一代碼文件）中的變量或對象，對普通類型（包括基本數據類、結構和類），可以利用關鍵字 extern，來使用這些變量或對象；但是對模板類型，則必須在定義這些模板類對象和模板函數時，使用標準 C++ 新增加的關鍵字 export（導出）。

Used to mark a template definition exported, which allows the same template to be declared, but not defined, in other translation units. (until C++11)

② Marks a declaration, a group of declarations, or another module as exported by the current module. (since C++20)

21 extern

extern（外部的）

① 聲明變量或函數為外部鏈接，即該變量或函數名在其它文件中可見。被其修飾的變量（外部變量）是靜態分配空間的，即程序開始時分配，結束時釋放。用其聲明的變量或函數應該在別的文件或同一文件的其它地方定義（實現）。在文件內聲明一個變量或函數默認為可被外部使用。② 指定使用另一語言進行鏈接，這時需要與特定的轉換符一起使用。目前僅支持 C 轉換標記，來支持 C 編譯器鏈接。使用這種情況有兩種形式：

<code>extern "C" 聲明語句
extern "C" { 聲明語句塊 }
/<code>

③ explicit template instantiation declaration (or "extern template")

<code>extern template class|struct template-name < argument-list > ;\t(2)\t(since C++11)
/<code>

22 false

false（假的），C++ 的基本數據結構 bool 類型的值之一。等同於 int 的 0 值。

23 float

float（浮點數）

C++ 中的基本數據類型，精度小於 double。（IEEE754）

24 for

① for 是 C++ 中的循環結構之一，一般用於重複次數確定的循環，在for()的()內寫三個表達式（用分號“;”分隔，分別表示循環變量的初始化、取邏輯值的判斷語句，循環變量更新語句），第一個語句可以寫到for前面，第二、三個語句可以寫到循環體中，但兩個分號“;”都不能被省略。

② range-based for loop: as the declaration of the loop (since C++11)

25 friend

friend（友元）聲明友元關係。友元可以訪問與其有 friend 關係的類中的 private/protected 成員，通過友元直接訪問類中的 private/protected 成員的主要目的是提高效率。友元包括友元函數和友元類。

26 goto

goto（轉到）

用於無條件跳轉到某一標號處開始執行。對應語言的jmp或jp系列條件跳轉命令。在沒有語句塊和控制結構語句之前，通常通過goto語句實現跳轉。往後跳可形成循環，往前跳可形成條件分支。

27 if

if（如果）

C++ 中的條件語句之一，可以根據後面的 bool 類型的值選擇進入一個分支執行。

28 inline

inline（內聯）函數的定義將在編譯時在調用處展開。inline 函數一般由短小的語句組成，可以提高程序效率。

29 int

int（整型，integer）

C++ 中的基本數據類型，用於表示整數，數據範圍（內存單元數量）小於 long。

30 long

long（長整型，long integer）

C++ 中的基本數據類型，用於表示長整數。

31 mutable

mutable（易變的）

C++ 中一個不常用的關鍵字。只能用於類的非靜態和非常量數據成員。由於一個對象的狀態由該對象的非靜態數據成員決定，所以隨著數據成員的改變，對象的狀態也會隨之發生變化。如果一個類的成員函數被聲明為 const 類型，表示該函數不會改變對象的狀態，也就是該函數不會修改類的非靜態數據成員。但是有些時候需要在該類函數中對類的數據成員進行賦值，這個時候就需要用到 mutable 關鍵字。

32 namespace

namespace（命名空間）用於在邏輯上組織類，是一種比類大的結構。用於包裹變量、自定義類型聲明、函數聲明，形成一個定義域。

33 new

用於新建一個對象。new 運算符總是返回一個指針。

new、delete在C++中定義為操作符函數，用於動態分配堆上內存。C++編譯器對new、delete的底層實現還是調用了malloc()和free()，但做了封裝，且C++編譯器對new、delete語句在編譯時做了一些額外的工作。

<code>Complex* pc = new Complex(1,2);            // 在堆上new一個對象：
                                           // 編譯器轉化為：
Complex *pc;
void* mem = operator new(sizeof(Complex)); // ① 分配內存，內部調用malloc(n)
pc = static_cast<complex>(mem);           // ② 轉型
pc->Complex::Copmlex(1,2);                 // ③ 調用構造函數
/<complex>/<code>

34 operator

operator（操作符）

用於操作符重載。這是 C++ 中的一種特殊的函數。

<code>operator op\t(1)\t
operator type\t(2)\t
operator new
operator new []\t(3)\t
operator delete
operator delete []\t        (4)\t
operator "" suffix-identifier\t(5) (since C++11)
operator co_await\t        (6) (since C++20)
/<code>

35 private

private（私有的）

C++ 中的訪問控制符。被標明為 private 的字段只能在本類成員函數以及友元函數或友元類的成員函數中訪問。

如果是B是private繼承自A，則A的全部成員雖是A的一部分，但不能被訪問(因為private部分只能由其成員函數訪問，因為其private繼承，成員函數也成了私有)。

36 protected

protected（受保護的）

C++ 中的訪問控制符。被標明為 protected 的字段只能在本類以及其繼承類和友元中訪問。

如果是B是protected繼承自A，則A的public和protected成員在B中變成了protected。

37 public

public（公有的）

C++ 中的訪問控制符。被標明為 public 的字段可以在任何類

38 register

register（寄存器）

聲明的變量稱著寄存器變量，在可能的情況下會直接存放在機器的寄存器中；但對 32 位編譯器不起作用，當 global optimizations（全局優化）開的時候，它會做出選擇是否放在自己的寄存器中；不過其它與 register 關鍵字有關的其它符號都對32位編譯器有效。

39 reinterpret_cast

reinpreter_cast<type> (expression)/<type>

type_to 必須是一個指針、引用、算術類型、函數指針或者成員指針。它可以把一個指針轉換成一個整數，也可以把一個整數轉換成一個指針（先把一個指針轉換成一個整數，在把該整數轉換成原類型的指針，還可以得到原先的指針值）。

40 return

return（返回）

用於在函數中返回值。程序在執行到 return 語句後立即返回，return 後面的語句無法執行到。

41 short

short（短整型，short integer）

C++ 中的基本數據類型，用於表示整數，數值範圍（或內存單元大小）小於 int。

42 signed

signed（有符號）

表明該類型是有符號數，和 unsigned 相反。數字類型（整型和浮點型）都可以用 signed 修飾。但默認就是 signed，所以一般不會顯式使用。

43 sizeof

由於 C++ 每種類型的大小都是由編譯器自行決定的，為了增加可移植性，可以用 sizeof 運算符獲得該數據類型佔用的字節數。

44 static

static（靜態的）

① 存續期：靜態變量作用範圍在一個文件內，程序開始時分配空間，結束時釋放空間，默認初始化為 0，使用時可改變其值。

② 文件鏈接性：靜態變量或靜態函數，只有本文件內的代碼才可訪問它，它的名字（變量名或函數名）在其它文件中不可見。因此也稱為"文件作用域"。

③ 靜態成員：在 C++ 類的成員變量被聲明為 static（稱為靜態成員變量），意味著它被該類的所有實例所共享，也就是說當某個類的實例修改了該靜態成員變量，其修改值為該類的其它所有實例所見；而類的靜態成員函數也只能訪問靜態成員（變量或函數）。類的靜態成員變量必須在聲明它的文件範圍內進行初始化才能使用，private 類型的也不例外。

45 static_cast

static_cast<type>(expression)/<type>

該運算符把 expression 轉換為 type_to 類型，但沒有運行時類型檢查來保證轉換的安全性。它主要有如下幾種用法：

① 用於類層次結構中基類和子類之間指針或引用的轉換。進行上行轉換（把子類的指針或引用轉換成基類表示）是安全的；進行下行轉換（把基類指針或引用轉換成子類表示）時，由於沒有動態類型檢查，所以是不安全的。

② 用於基本數據類型之間的轉換，如把 int 轉換成 char，把 int 轉換成 enum。這種轉換的安全性也要開發人員來保證。

③ 把空指針轉換成目標類型的空指針。

④ 把任何類型的表達式轉換成void類?

注意 static_cast 不能轉換掉 expression 的 const、volitale、或者 __unaligned 屬性。

46 struct

struct（結構）

類似於 class 關鍵字，與 C 語言兼容（class 關鍵字是不與 C 語言兼容的），可以實現面向對象程序設計。

enum struct|class name { enumerator = constexpr , enumerator = constexpr , ... }

47 switch

switch（轉換）

類似於 if-else-if 語句，是一種多分枝語句。它提供了一種簡潔的書寫，並且能夠生成效率更好的代碼。但是，switch 後面的判斷只能是int（char也可以，但char本質上也是一種int類型）。switch 語句最後的 default 分支是可選的。

48 template

template（模板）

C++ 中泛型機制的實現。

49 this

關鍵字this是一個prvalue（純右值）表達式，其值是調用成員函數的對象的地址。

<code>#include<iostream>

class T
{
    int x;
public:
    void foo()       // implicitly including a pointer: void foo(T* this)
    {
        x = 6;       // same as this->x = 6;
        this->x = 5; // explicit use of this->
\t\tstd::cout<    }
};
void main()
{
    T obj;
\tobj.foo();      // obj. as obj* this;
}
/<iostream>/<code>

this指針有時可以顯式使用，有時不能。

50 throw

throw（拋出）

用於實現 C++ 的異常處理機制，可以通過 throw 關鍵字"拋出"一個異常。

try或try調用的函數中throw exception。

51 true

true（真的）

C++ 的基本數據結構 bool 類型的值之一。等同於 int 的非 0 值。

52 try

try（嘗試）

用於實現 C++ 的異常處理機制。可以在 try 中調用可能拋出異常的函數，然後在 try 後面的 catch 中捕獲並進行處理。

try或try調用的函數中throw exception。

<code>try {
   std::string("abc").substr(10);   // throws std::length_error
} catch (const std::exception& e) { // reference to the base of a polymorphic object
     std::cout << e.what();         // information from length_error printed
}
/<code>

53 typedef

typedef（類型定義，type define）

typedef typeDeclaration newTypeName;

類型說明定義了一個數據類型的新名字而不是定義一種新的數據類型。定義名錶示這個類型的新名字。

<code>// simple typedef
typedef unsigned long ulong;
 
// common C idiom to avoid having to write "struct S"
typedef struct {int a; int b;} S, *pS;

// function pointer
typedef void (*pf)(int,double);

// std::add_const, like many other metafunctions, use member typedefs
template< class T>
struct add_const {
    typedef const T type; 

};

/<code>

54 typeid

指出指針或引用指向的對象的實際派生類型。

55 typename

在模板函數或模板類中，typename（類型名字）關鍵字告訴編譯器把一個特殊的名字解釋成一個類型。在下列情況下必須對一個 name 使用 typename 關鍵字：

55.1 一個唯一的name（可以作為類型理解），它嵌套在另一個類型中的。

55.2 依賴於一個模板參數，就是說：模板參數在某種程度上包含這個name。當模板參數使編譯器在指認一個類型時產生了誤解。

In a template declaration, typename can be used as an alternative to class to declare type template parameters and template template parameters (since C++17).

Inside a declaration or a definition of a template, typename can be used to declare that a dependent qualified name is a type.

Inside a declaration or a definition of a template, (until C++11) typename can be used before a non-dependent qualified type name. It has no effect in this case.

Inside a requirements for type requirements (since C++20)

56 union

union（聯合）

不同的數據成員共用一段內存單元空間，使用相同的地址，其內存的大小取決於所有成員中佔用空間最大的成員。

A union is a struct in which all members are allocated at the same address so that the union occupies only as much space as its largest member. Naturally, a union can hold a value for only one member at a time.

使用場合：當兩個結構體的成員只有一個不同時，兩個結構體可以通過一個union合併成一個結構體：

<code>struct staff{    
    int num;    
    char name[10];    
    char sex;    
    char job;    
    union    
    {        
        int banji;        
        char position[10];    
    }category;    
}staff[12];
/<code>

57 unsigned

unsigned（無符號）

表明該類型是無符號數，和 signed 相反。

58 using

表明使用 namespace。

59 virtual

virtual（虛的）

① C++ 中用來實現多態機制，聲明虛函數（包括虛析構函數，不能是虛構造函數）。

② 虛繼承其類，解決菱形繼承問題。

60 void

void（空的）

可以作為函數返回值，表明不返回任何數據；可以作為參數，表明沒有參數傳入（C++中不是必須的）；void*可以作為指針使用。

void通常用於表示類型暫定，對於強類型語言，為了實現一些運算符或函數的通用性，通常首先將類型表示為void，最終類型轉換為具體類型。如malloc()、new、qsort()等。

61 volatile

volatile（不穩定的）

① 限定一個對象可被外部進程（操作系統、硬件或併發線程等）改變，聲明時的語法如下：

int volatile nVint;

這樣的聲明是不能達到最高效的，因為它們的值隨時會改變，系統在需要時會經常讀寫這個對象的值。因此常用於像中斷處理程序之類的異步進程進行內存單元訪問。

② volatile-qualified member functions。

62 wchar_t

wchar_t（wide character typedef）是寬字符類型，每個 wchar_t 類型佔 2 個字節，16 位寬。漢字的表示就要用到 wchar_t。

Required to be large enough to represent any supported character code point (32 bits on systems that support Unicode. A notable exception is Windows, where wchar_t is 16 bits and holds UTF-16 code units) It has the same size, signedness, and alignment as one of the integer types, but is a distinct type.

63 while

while用於表示一個循環，相對於for的重複次數相對確定，while常用於表示一些重複次數不確定的循環。

－End－

閱讀更多 小智雅匯 的文章

關鍵字: 數據結構 思維 導圖