The article is from http://www.runoob.com/cplusplus/cpp-operators.html

Thanks!!!

C++ 儲存類

儲存類定義 C++ 程式中變數/函式的範圍（可見性）和生命週期。這些說明符放置在它們所修飾的型別之前。下面列出 C++ 程式中可用的儲存類：

• auto
• register
• static
• extern
• mutable
• thread_local (C++11)

從 C++ 11 開始，auto 關鍵字不再是 C++ 儲存類說明符，且 register 關鍵字被棄用。

auto 儲存類

自 C++ 11 以來，auto 關鍵字用於兩種情況：宣告變數時根據初始化表示式自動推斷該變數的型別、宣告函式時函式返回值的佔位符。

C++98標準中auto關鍵字用於自動變數的宣告，但由於使用極少且多餘，在C++11中已刪除這一用法。

根據初始化表示式自動推斷被宣告的變數的型別，如：

auto f=3.14;      //double
auto s("hello");  //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//錯誤，必須是初始化為同一型別

register 儲存類

register

儲存類用於定義儲存在暫存器中而不是 RAM 中的區域性變數。這意味著變數的最大尺寸等於暫存器的大小（通常是一個詞），且不能對它應用一元的 '&' 運算子（因為它沒有記憶體位置）。

{ 
    register int miles; 
}

暫存器只用於需要快速訪問的變數，比如計數器。還應注意的是，定義 'register' 並不意味著變數將被儲存在暫存器中，它意味著變數可能儲存在暫存器中，這取決於硬體和實現的限制。

static 儲存類

static 儲存類指示編譯器在程式的生命週期內保持區域性變數的存在，而不需要在每次它進入和離開作用域時進行建立和銷燬。因此，使用 static 修飾區域性變數可以在函式呼叫之間保持區域性變數的值。

static 修飾符也可以應用於全域性變數。當 static 修飾全域性變數時，會使變數的作用域限制在宣告它的檔案內。

在 C++ 中，當 static 用在類資料成員上時，會導致僅有一個該成員的副本被類的所有物件共享。

#include <iostream>
 
// 函式宣告 
void func(void);
 
static int count = 10; /* 全域性變數 */
 
int main()
{
    while(count--)
    {
       func();
    }
    return 0;
}
// 函式定義
void func( void )
{
    static int i = 5; // 區域性靜態變數
    i++;
    std::cout << "變數 i 為 " << i ;
    std::cout << " , 變數 count 為 " << count << std::endl;
}

當上面的程式碼被編譯和執行時，它會產生下列結果：

變數 i 為 6 , 變數 count 為 9
變數 i 為 7 , 變數 count 為 8
變數 i 為 8 , 變數 count 為 7
變數 i 為 9 , 變數 count 為 6
變數 i 為 10 , 變數 count 為 5
變數 i 為 11 , 變數 count 為 4
變數 i 為 12 , 變數 count 為 3
變數 i 為 13 , 變數 count 為 2
變數 i 為 14 , 變數 count 為 1
變數 i 為 15 , 變數 count 為 0

extern 儲存類

extern 儲存類用於提供一個全域性變數的引用，全域性變數對所有的程式檔案都是可見的。當您使用 'extern' 時，對於無法初始化的變數，會把變數名指向一個之前定義過的儲存位置。

當您有多個檔案且定義了一個可以在其他檔案中使用的全域性變數或函式時，可以在其他檔案中使用 extern 來得到已定義的變數或函式的引用。可以這麼理解，extern 是用來在另一個檔案中宣告一個全域性變數或函式。

extern 修飾符通常用於當有兩個或多個檔案共享相同的全域性變數或函式的時候，如下所示：

第一個檔案：main.cpp

#include <iostream>
 
int count ;
extern void write_extern();
 
int main()
{
   count = 5;
   write_extern();
}

第二個檔案：support.cpp

#include <iostream>
 
extern int count;
 
void write_extern(void)
{
   std::cout << "Count is " << count << std::endl;
}

在這裡，第二個檔案中的 extern 關鍵字用於宣告已經在第一個檔案 main.cpp 中定義的 count。現在 ，編譯這兩個檔案，如下所示：

$ g++ main.cpp support.cpp -o write

這會產生 write 可執行程式，嘗試執行 write，它會產生下列結果：

$ ./write 
Count is 5

mutable 儲存類

mutable 說明符僅適用於類的物件，這將在本教程的最後進行講解。它允許物件的成員替代常量。也就是說，mutable 成員可以通過 const 成員函式修改。

thread_local 儲存類???

使用 thread_local 說明符宣告的變數僅可在它在其上建立的執行緒上訪問。 變數在建立執行緒時建立，並在銷燬執行緒時銷燬。 每個執行緒都有其自己的變數副本。

thread_local 說明符可以與 static 或 extern 合併。

可以將 thread_local 僅應用於資料宣告和定義，thread_local 不能用於函式宣告或定義。

以下演示了可以被宣告為 thread_local 的變數：

thread_local int x;  // 名稱空間下的全域性變數
class X
{
    static thread_local std::string s; // 類的static成員變數
};
static thread_local std::string X::s;  // X::s 是需要定義的
 
void foo()
{
    thread_local std::vector<int> v;  // 本地變數
}

---

---

---

C++ 運算子

運算子是一種告訴編譯器執行特定的數學或邏輯操作的符號。C++ 內建了豐富的運算子，並提供了以下型別的運算子：

• 算術運算子
• 關係運算符
• 邏輯運算子
• 位運算子
• 賦值運算子
• 雜項運算子

算術運算子

下表顯示了 C++ 支援的算術運算子。

假設變數 A 的值為 10，變數 B 的值為 20，則：

運算子	描述	例項
+	把兩個運算元相加	A + B 將得到 30
-	從第一個運算元中減去第二個運算元	A - B 將得到 -10
*	把兩個運算元相乘	A * B 將得到 200
/	分子除以分母	B / A 將得到 2
%	取模運算子，整除後的餘數	B % A 將得到 0
++	自增運算子，整數值增加 1	A++ 將得到 11
--	自減運算子，整數值減少 1	A-- 將得到 9

關係運算符

下表顯示了 C++ 支援的關係運算符。

假設變數 A 的值為 10，變數 B 的值為 20，則：

運算子	描述	例項
==	檢查兩個運算元的值是否相等，如果相等則條件為真。	(A == B) 不為真。
!=	檢查兩個運算元的值是否相等，如果不相等則條件為真。	(A != B) 為真。
>	檢查左運算元的值是否大於右運算元的值，如果是則條件為真。	(A > B) 不為真。
<	檢查左運算元的值是否小於右運算元的值，如果是則條件為真。	(A < B) 為真。
>=	檢查左運算元的值是否大於或等於右運算元的值，如果是則條件為真。	(A >= B) 不為真。
<=	檢查左運算元的值是否小於或等於右運算元的值，如果是則條件為真。	(A <= B) 為真。

邏輯運算子

下表顯示了 C++ 支援的關係邏輯運算子。

假設變數 A 的值為 1，變數 B 的值為 0，則：

運算子	描述	例項
&&	稱為邏輯與運算子。如果兩個運算元都非零，則條件為真。	(A && B) 為假。
||	稱為邏輯或運算子。如果兩個運算元中有任意一個非零，則條件為真。	(A || B) 為真。
!	稱為邏輯非運算子。用來逆轉運算元的邏輯狀態。如果條件為真則邏輯非運算子將使其為假。	!(A && B) 為真。

位運算子

位運算子作用於位，並逐位執行操作。&、 | 和 ^ 的真值表如下所示：

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

假設如果 A = 60，且 B = 13，現在以二進位制格式表示，它們如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

下表顯示了 C++ 支援的位運算子。假設變數 A 的值為 60，變數 B 的值為 13，則：

運算子	描述	例項
&	如果同時存在於兩個運算元中，二進位制 AND 運算子複製一位到結果中。	(A & B) 將得到 12，即為 0000 1100
|	如果存在於任一運算元中，二進位制 OR 運算子複製一位到結果中。	(A | B) 將得到 61，即為 0011 1101
^	如果存在於其中一個運算元中但不同時存在於兩個運算元中，二進位制異或運算子複製一位到結果中。	(A ^ B) 將得到 49，即為 0011 0001
~	二進位制補碼運算子是一元運算子，具有"翻轉"位效果，即0變成1，1變成0。	(~A ) 將得到 -61，即為 1100 0011，一個有符號二進位制數的補碼形式。
<<	二進位制左移運算子。左運算元的值向左移動右運算元指定的位數。	A << 2 將得到 240，即為 1111 0000
>>	二進位制右移運算子。左運算元的值向右移動右運算元指定的位數。	A >> 2 將得到 15，即為 0000 1111

賦值運算子

下表列出了 C++ 支援的賦值運算子：

運算子	描述	例項
=	簡單的賦值運算子，把右邊運算元的值賦給左邊運算元	C = A + B 將把 A + B 的值賦給 C
+=	加且賦值運算子，把右邊運算元加上左邊運算元的結果賦值給左邊運算元	C += A 相當於 C = C + A
-=	減且賦值運算子，把左邊運算元減去右邊運算元的結果賦值給左邊運算元	C -= A 相當於 C = C - A
*=	乘且賦值運算子，把右邊運算元乘以左邊運算元的結果賦值給左邊運算元	C *= A 相當於 C = C * A
/=	除且賦值運算子，把左邊運算元除以右邊運算元的結果賦值給左邊運算元	C /= A 相當於 C = C / A
%=	求模且賦值運算子，求兩個運算元的模賦值給左邊運算元	C %= A 相當於 C = C % A
<<=	左移且賦值運算子	C <<= 2 等同於 C = C << 2
>>=	右移且賦值運算子	C >>= 2 等同於 C = C >> 2
&=	按位與且賦值運算子	C &= 2 等同於 C = C & 2
^=	按位異或且賦值運算子	C ^= 2 等同於 C = C ^ 2
|=	按位或且賦值運算子	C |= 2 等同於 C = C | 2

雜項運算子

下表列出了 C++ 支援的其他一些重要的運算子。

運算子	描述
sizeof	sizeof 運算子返回變數的大小。例如，sizeof(a) 將返回 4，其中 a 是整數。
Condition ? X : Y	條件運算子。如果 Condition 為真 ? 則值為 X : 否則值為 Y。
,	逗號運算子會順序執行一系列運算。整個逗號表示式的值是以逗號分隔的列表中的最後一個表示式的值。
.（點）和 ->（箭頭）	成員運算子用於引用類、結構和共用體的成員。
Cast	強制轉換運算子把一種資料型別轉換為另一種資料型別。例如，int(2.2000) 將返回 2。
&	指標運算子 & 返回變數的地址。例如 &a; 將給出變數的實際地址。
*	指標運算子 * 指向一個變數。例如，*var; 將指向變數 var。

C++ 中的運算子優先順序

運算子的優先順序確定表示式中項的組合。這會影響到一個表示式如何計算。某些運算子比其他運算子有更高的優先順序，例如，乘除運算子具有比加減運算子更高的優先順序。

例如 x = 7 + 3 * 2，在這裡，x 被賦值為 13，而不是 20，因為運算子 * 具有比 + 更高的優先順序，所以首先計算乘法 3*2，然後再加上 7。

下表將按運算子優先順序從高到低列出各個運算子，具有較高優先順序的運算子出現在表格的上面，具有較低優先順序的運算子出現在表格的下面。在表示式中，較高優先順序的運算子會優先被計算。

類別	運算子	結合性
字尾	() [] -> . ++ - -	從左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	從右到左
乘除	* / %	從左到右
加減	+ -	從左到右
移位	<< >>	從左到右
關係	< <= > >=	從左到右
相等	== !=	從左到右
位與 AND	&	從左到右
位異或 XOR	^	從左到右
位或 OR	|	從左到右
邏輯與 AND	&&	從左到右
邏輯或 OR	||	從左到右
條件	?:	從右到左
賦值	= += -= *= /= %=>>= <<= &= ^= |=	從右到左
逗號	,	從左到右