C++?注釋

程序的注釋是解釋性語句，您可以在 C++ 代碼中包含注釋，這將提高源代碼的可讀性。所有的編程語言都允許某種形式的注釋。

C++ 支持單行注釋和多行注釋。注釋中的所有字符會被 C++ 編譯器忽略。

C++ 注釋以 /* 開始，以 */ 終止。例如：

/* 這是注釋 *//* C++ 注釋也可以* 跨行*/

注釋也能以 // 開始，直到行末為止。例如：

#include using namespace std;main() { ? cout << "Hello World"; // 輸出 Hello World ? ? return 0;?}

當上面的代碼被編譯時，編譯器會忽略?// prints Hello World，最后會產生以下結果：

Hello World

在 /* 和 */ 注釋內部，// 字符沒有特殊的含義。在 // 注釋內，/* 和 */ 字符也沒有特殊的含義。因此，您可以在一種注釋內嵌套另一種注釋。例如：

/* 用于輸出 Hello World 的注釋cout << "Hello World"; // 輸出 Hello World ?*/

C++?數據類型

使用編程語言進行編程時，需要用到各種變量來存儲各種信息。變量保留的是它所存儲的值的內存位置。這意味著，當您創建一個變量時，就會在內存中保留一些空間。

您可能需要存儲各種數據類型（比如字符型、寬字符型、整型、浮點型、雙浮點型、布爾型等）的信息，操作系統會根據變量的數據類型，來分配內存和決定在保留內存中存儲什么。

基本的內置類型

C++ 為程序員提供了種類豐富的內置數據類型和用戶自定義的數據類型。下表列出了七種基本的 C++ 數據類型：

類型關鍵字

布爾型	bool
字符型	char
整型	int
浮點型	float
雙浮點型	double
無類型	void
寬字符型	wchar_t

一些基本類型可以使用一個或多個類型修飾符進行修飾：

• signed

• unsigned

• short

• long

下表顯示了各種變量類型在內存中存儲值時需要占用的內存，以及該類型的變量所能存儲的最大值和最小值。

類型位寬度范圍

char	1 個字節	-127 到 127 或者 0 到 255
unsigned char	1 個字節	0 到 255
signed char	1 個字節	-127 到 127
int	4 個字節	-2147483648 到 2147483647
unsigned int	4 個字節	0 到 4294967295
signed int	4 個字節	-2147483648 到 2147483647
short int	2 個字節	-32768 到 32767
unsigned short int	Range	0 到 65,535
signed short int	Range	-32768 到 32767
long int	4 個字節	-2,147,483,647 到 2,147,483,647
signed long int	4 個字節	與 long int 相同
unsigned long int	4 個字節	0 到 4,294,967,295
float	4 個字節	+/- 3.4e +/- 38 (~7 個數字)
double	8 個字節	+/- 1.7e +/- 308 (~15 個數字)
long double	8 個字節	+/- 1.7e +/- 308 (~15 個數字)
wchar_t	2 或 4 個字節	1 個寬字符

從上表可得知，變量的大小會根據編譯器和所使用的電腦而有所不同。

下面實例會輸出您電腦上各種數據類型的大小。

#include <iostream>using namespace std;int main(){ ? cout << "Size of char : " << sizeof(char) << endl; ? cout << "Size of int : " << sizeof(int) << endl; ? cout << "Size of short int : " << sizeof(short int) << endl; ? cout << "Size of long int : " << sizeof(long int) << endl; ? cout << "Size of float : " << sizeof(float) << endl; ? cout << "Size of double : " << sizeof(double) << endl; ? cout << "Size of wchar_t : " << sizeof(wchar_t) << endl; ? return 0; }

本實例使用了?endl，這將在每一行后插入一個換行符，<< 運算符用于向屏幕傳多個值。我們也使用?sizeof()?函數來獲取各種數據類型的大小。

當上面的代碼被編譯和執行時，它會產生以下的結果，結果會根據所使用的計算機而有所不同：

Size of char : 1 Size of int : 4 Size of short int : 2 Size of long int : 4 Size of float : 4 Size of double : 8 Size of wchar_t : 4

typedef 聲明

您可以使用?typedef?為一個已有的類型取一個新的名字。下面是使用 typedef 定義一個新類型的語法：

typedef type newname;

例如，下面的語句會告訴編譯器，feet 是 int 的另一個名稱：

typedef int feet;

現在，下面的聲明是完全合法的，它創建了一個整型變量 distance：

feet distance;

枚舉類型

枚舉類型聲明一個可選的類型名稱和一組標識符，用來作為該類型的值。其帶有零個或多個標識符可以被用來作為該類型的值。每個枚舉數是一個枚舉類型的常數。

創建枚舉，需要使用關鍵字?enum。枚舉類型的一般形式為：

enum enum-name { list of names } var-list;

在這里，enum-name 是枚舉類型的名稱。名稱列表 { list of names } 是用逗號分隔的。

例如，下面的代碼定義了一個顏色枚舉，變量 c 的類型為 color。最后，c 被賦值為 "blue"。

enum color { red, green, blue } c; c = blue;

默認情況下，第一個名稱的值為 0，第二個名稱的值為 1，第三個名稱的值為 2，以此類推。但是，您也可以給名稱賦予一個特殊的值，只需要添加一個初始值即可。例如，在下面的枚舉中，green?的值為 5。

enum color { red, green=5, blue };

在這里，blue?的值為 6，因為默認情況下，每個名稱都會比它前面一個名稱大 1。

C++?變量作用域

作用域是程序的一個區域，一般來說有三個地方可以聲明變量：

• 在函數或一個代碼塊內部聲明的變量，稱為局部變量。

• 在函數參數的定義中聲明的變量，稱為形式參數。

• 在所有函數外部聲明的變量，稱為全局變量。

我們將在后續的章節中學習什么是函數和參數。本章我們先來講解聲明是局部變量和全局變量。

局部變量

在函數或一個代碼塊內部聲明的變量，稱為局部變量。它們只能被函數內部或者代碼塊內部的語句使用。下面的實例使用了局部變量：

#include <iostream> using namespace std;int main () {// 局部變量聲明int a, b;int c;// 實際初始化a = 10;b = 20;c = a + b;cout << c; ? ? return 0; }

全局變量

在所有函數外部定義的變量（通常是在程序的頭部），稱為全局變量。全局變量的值在程序的整個生命周期內都是有效的。

全局變量可以被任何函數訪問。也就是說，全局變量一旦聲明，在整個程序中都是可用的。下面的實例使用了全局變量和局部變量：

#include <iostream>using namespace std; // 全局變量聲明int g; int main (){ ?// 局部變量聲明int a, b;// 實際初始化a = 10;b = 20;g = a + b;cout << g; ? ? return 0;}

在程序中，局部變量和全局變量的名稱可以相同，但是在函數內，局部變量的值會覆蓋全局變量的值。下面是一個實例：

#include <iostream>using namespace std; // 全局變量聲明int g = 20; int main (){ ?// 局部變量聲明int g = 10;cout << g; ? ? return 0; }

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

10

初始化局部變量和全局變量

當局部變量被定義時，系統不會對其初始化，您必須自行對其初始化。定義全局變量時，系統會自動初始化為下列值：

數據類型初始化默認值

int	0
char	'\0'
float	0
double	0
pointer	NULL

正確地初始化變量是一個良好的編程習慣，否則有時候程序可能會產生意想不到的結果。

C++?常量

常量是固定值，在程序執行期間不會改變。這些固定的值，又叫做字面量。

常量可以是任何的基本數據類型，可分為整型數字、浮點數字、字符、字符串和布爾值。

常量就像是常規的變量，只不過常量的值在定義后不能進行修改。

整數常量

整數常量可以是十進制、八進制或十六進制的常量。前綴指定基數：0x 或 0X 表示十六進制，0 表示八進制，不帶前綴則默認表示十進制。

整數常量也可以帶一個后綴，后綴是 U 和 L 的組合，U 表示無符號整數（unsigned），L 表示長整數（long）。后綴可以是大寫，也可以是小寫，U 和 L 的順序任意。

下面列舉幾個整數常量的實例：

212 ? ? ? ? // 合法的 215u ? ? ? ?// 合法的 0xFeeL ? ? ?// 合法的 078 ? ? ? ? // 非法的：8 不是八進制的數字 032UU ? ? ? // 非法的：不能重復后綴

以下是各種類型的整數常量的實例：

85 ? ? ? ? // 十進制 0213 ? ? ? // 八進制 0x4b ? ? ? // 十六進制 30 ? ? ? ? // 整數 30u ? ? ? ?// 無符號整數 30l ? ? ? ?// 長整數 30ul ? ? ? // 無符號長整數

浮點常量

浮點常量由整數部分、小數點、小數部分和指數部分組成。您可以使用小數形式或者指數形式來表示浮點常量。

當使用小數形式表示時，必須包含小數點、指數，或同時包含兩者。當使用指數形式表示時，必須包含整數部分、小數部分，或同時包含兩者。帶符號的指數是用 e 或 E 引入的。

下面列舉幾個浮點常量的實例：

3.14159 ? ? ? // 合法的 314159E-5L ? ?// 合法的 510E ? ? ? ? ?// 非法的：不完整的指數 210f ? ? ? ? ?// 非法的：沒有小數或指數 .e55 ? ? ? ? ?// 非法的：缺少整數或分數

布爾常量

布爾常量共有兩個，它們都是標準的 C++ 關鍵字：

• true?值代表真。

• false?值代表假。

我們不應把 true 的值看成 1，把 false 的值看成 0。

字符常量

字符常量是括在單引號中。如果常量以 L（僅當大寫時）開頭，則表示它是一個寬字符常量（例如 L'x'），此時它必須存儲在?wchar_t?類型的變量中。否則，它就是一個窄字符常量（例如 'x'），此時它可以存儲在?char?類型的簡單變量中。

字符常量可以是一個普通的字符（例如 'x'）、一個轉義序列（例如 '\t'），或一個通用的字符（例如 '\u02C0'）。

在 C++ 中，有一些特定的字符，當它們前面有反斜杠時，它們就具有特殊的含義，被用來表示如換行符（\n）或制表符（\t）等。下表列出了一些這樣的轉義序列碼：

轉義序列含義

\\	\ 字符
\'	' 字符
\"	" 字符
\?	? 字符
\a	警報鈴聲
\b	退格鍵
\f	換頁符
\n	換行符
\r	回車
\t	水平制表符
\v	垂直制表符
\ooo	一到三位的八進制數
\xhh . . .	一個或多個數字的十六進制數

下面的實例顯示了一些轉義序列字符：

#include <iostream>using namespace std;int main(){ ? cout << "Hello\tWorld\n\n"; ? return 0;}

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

Hello ? World

字符串常量

字符串字面值或常量是括在雙引號 "" 中的。一個字符串包含類似于字符常量的字符：普通的字符、轉義序列和通用的字符。

您可以使用空格做分隔符，把一個很長的字符串常量進行分行。

下面的實例顯示了一些字符串常量。下面這三種形式所顯示的字符串是相同的。

"hello, dear""hello, \dear""hello, " "d" "ear"

定義常量

在 C++ 中，有兩種簡單的定義常量的方式：

• 使用?#define?預處理器。

• 使用?const?關鍵字。

#define 預處理器

下面是使用 #define 預處理器定義常量的形式：

#define identifier value

具體請看下面的實例：

#include <iostream>using namespace std;#define LENGTH 10 ? #define WIDTH ?5#define NEWLINE '\n'int main(){ ? int area; ?area = LENGTH * WIDTH; ? cout << area; ? cout << NEWLINE; ? return 0; }

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

50

const 關鍵字

您可以使用?const?前綴聲明指定類型的常量，如下所示：

const type variable = value;

具體請看下面的實例：

#include <iostream>using namespace std;int main(){ ? const int ?LENGTH = 10; ? const int ?WIDTH ?= 5; ? const char NEWLINE = '\n'; ? int area; ?area = LENGTH * WIDTH; ? cout << area; ? cout << NEWLINE; ? return 0; }

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

50

請注意，把常量定義為大寫字母形式，是一個很好的編程實踐

C++?修飾符類型

C++ 允許在?char、int 和 double?數據類型前放置修飾符。修飾符用于改變基本類型的含義，所以它更能滿足各種情境的需求。

下面列出了數據類型修飾符：

• signed

• unsigned

• long

• short

修飾符?signed、unsigned、long 和 short?可應用于整型，signed?和?unsigned?可應用于字符型，long?可應用于雙精度型。

修飾符?signed?和?unsigned?也可以作為?long?或?short?修飾符的前綴。例如：unsigned long int。

C++ 允許使用速記符號來聲明無符號短整數或無符號長整數。您可以不寫 int，只寫單詞?unsigned short?或?unsigned long，int 是隱含的。例如，下面的兩個語句都聲明了無符號整型變量。

unsigned x; unsigned int y;

為了理解 C++ 解釋有符號整數和無符號整數修飾符之間的差別，我們來運行一下下面這個短程序：

#include <iostream>using namespace std; /** 這個程序演示了有符號整數和無符號整數之間的差別 */int main(){ ? short int i; ? ? ? ? ? // 有符號短整數short unsigned int j; ?// 無符號短整數j = 50000;i = j; ? cout << i << " " << j; ? return 0; }

當上面的程序運行時，會輸出下列結果：

-15536 50000

上述結果中，無符號短整數 50,000 的位模式被解釋為有符號短整數 -15,536。

C++ 中的類型限定符

類型限定符提供了變量的額外信息。

限定符含義

const	const?類型的對象在程序執行期間不能被修改改變。
volatile	修飾符?volatile?告訴編譯器，變量的值可能以程序未明確指定的方式被改變。
restrict	由?restrict?修飾的指針是唯一一種訪問它所指向的對象的方式。只有 C99 增加了新的類型限定符 restrict。

C++?存儲類

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

• auto

• register

• static

• extern

• mutable

auto 存儲類

auto?存儲類是所有局部變量默認的存儲類。

{int mount;auto int month; }

上面的實例定義了兩個帶有相同存儲類的變量，auto 只能用在函數內，即 auto 只能修飾局部變量。

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();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 成員函數修改。

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++ 中所有可用的算術運算符。

復制并黏貼下面的 C++ 程序到 test.cpp 文件中，編譯并運行程序。

#include <iostream>using namespace std;main() { ? int a = 21; ? int b = 10; ? int c ;c = a + b; ? cout << "Line 1 - c 的值是 " << c << endl ;c = a - b;cout << "Line 2 - c 的值是 " << c << endl ;c = a * b;cout << "Line 3 - c 的值是 " << c << endl ;c = a / b;cout << "Line 4 - c 的值是 " << c << endl ;c = a % b;cout << "Line 5 - c 的值是 " << c << endl ;c = a++;cout << "Line 6 - c 的值是 " << c << endl ;c = a--;cout << "Line 7 - c 的值是 " << c << endl ;return 0; }

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

Line 1 - c 的值是 31 Line 2 - c 的值是 11 Line 3 - c 的值是 210 Line 4 - c 的值是 2 Line 5 - c 的值是 1 Line 6 - c 的值是 21 Line 7 - c 的值是 22

關系運算符

下表顯示了 C++ 支持的所有關系運算符。

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

運算符描述實例

==	檢查兩個操作數的值是否相等，如果相等則條件為真。	(A == B) 不為真。
!=	檢查兩個操作數的值是否相等，如果不相等則條件為真。	(A != B) 為真。
>	檢查左操作數的值是否大于右操作數的值，如果是則條件為真。	(A > B) 不為真。
<	檢查左操作數的值是否小于右操作數的值，如果是則條件為真。	(A < B) 為真。
>=	檢查左操作數的值是否大于或等于右操作數的值，如果是則條件為真。	(A >= B) 不為真。
<=	檢查左操作數的值是否小于或等于右操作數的值，如果是則條件為真。	(A <= B) 為真。

實例

請看下面的實例，了解 C++ 中所有可用的關系運算符。

復制并黏貼下面的 C++ 程序到 test.cpp 文件中，編譯并運行程序。

#include <iostream>using namespace std;main() { ? int a = 21; ? int b = 10; ? int c ; ? if( a == b ){ ? ? ?cout << "Line 1 - a 等于 b" << endl ;}else{cout << "Line 1 - a 不等于 b" << endl ;}if ( a < b ) {cout << "Line 2 - a 小于 b" << endl ;}else{cout << "Line 2 - a 不小于 b" << endl ;}if ( a > b ){ ? ? ?cout << "Line 3 - a 大于 b" << endl ;}else{cout << "Line 3 - a 不大于 b" << endl ;} ? ?/* 改變 a 和 b 的值 */????a = 5;b = 20;if ( a <= b ){cout << "Line 4 - a 小于或等于 b" << endl ;}if ( b >= a ){ ? ? ?cout << "Line 5 - b 大于或等于 b" << endl ;}return 0; }

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

Line 1 - a 不等于 b Line 2 - a 不小于 b Line 3 - a 大于 b Line 4 - a 小于或等于 b Line 5 - b 大于或等于 b

邏輯運算符

下表顯示了 C++ 支持的所有關系邏輯運算符。

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

運算符描述實例

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

實例

請看下面的實例，了解 C++ 中所有可用的邏輯運算符。

復制并黏貼下面的 C++ 程序到 test.cpp 文件中，編譯并運行程序。

#include <iostream>using namespace std;main() { ? int a = 5; ? int b = 20; ? int c ; ? if ( a && b ){ ? ? ?cout << "Line 1 - 條件為真"<< endl ;}if ( a || b ){cout << "Line 2 - 條件為真"<< endl ;} ? ?/* 改變 a 和 b 的值 */????a = 0;b = 10;if ( a && b ){cout << "Line 3 - 條件為真"<< endl ;}else{cout << "Line 4 - 條件不為真"<< endl ;}if ( !(a && b) ){cout << "Line 5 - 條件為真"<< endl ;}return 0; }

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

Line 1 - 條件為真 Line 2 - 條件為真 Line 3 - 條件不為真 Line 4 - 條件為真

位運算符

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

pqp & qp | qp ^ 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
~	二進制補碼運算符是一元運算符，具有"翻轉"位效果。	(~A ) 將得到 -61，即為 1100 0011，2 的補碼形式，帶符號的二進制數。
<<	二進制左移運算符。左操作數的值向左移動右操作數指定的位數。	A << 2 將得到 240，即為 1111 0000
>>	二進制右移運算符。左操作數的值向右移動右操作數指定的位數。	A >> 2 將得到 15，即為 0000 1111

實例

請看下面的實例，了解 C++ 中所有可用的位運算符。

復制并黏貼下面的 C++ 程序到 test.cpp 文件中，編譯并運行程序。

#include <iostream>using namespace std;main() { ? unsigned int a = 60; ? ? // 60 = 0011 1100 ?unsigned int b = 13; ? ?// 13 = 0000 1101int c = 0; ? ? ? ? ?c = a & b; ? ? ? ? ? ? // 12 = 0000 1100cout << "Line 1 - c 的值是 " << c << endl ;c = a | b; ? ? ? ? ? ? // 61 = 0011 1101????cout << "Line 2 - c 的值是 " << c << endl ;c = a ^ b; ? ? ? ? ? ? // 49 = 0011 0001????cout << "Line 3 - c 的值是 " << c << endl ;c = ~a; ? ? ? ? ? ? ? ?// -61 = 1100 0011????cout << "Line 4 - c 的值是 " << c << endl ;c = a << 2; ? ? ? ? ? ?// 240 = 1111 0000????cout << "Line 5 - c 的值是 " << c << endl ;c = a >> 2; ? ? ? ? ? ?// 15 = 0000 1111cout << "Line 6 - c 的值是 " << c << endl ;return 0; }

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

Line 1 - c 的值是 12 Line 2 - c 的值是 61 Line 3 - c 的值是 49 Line 4 - c 的值是 -61 Line 5 - c 的值是 240 Line 6 - c 的值是 15

賦值運算符

下表列出了 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++ 中所有可用的賦值運算符。

復制并黏貼下面的 C++ 程序到 test.cpp 文件中，編譯并運行程序。

#include <iostream>using namespace std;main() { ? int a = 21; ? int c ;c = ?a; ? cout << "Line 1 - = ?運算符實例，c 的值 = : " <<c<< endl ;c += ?a;cout << "Line 2 - += 運算符實例，c 的值 = : " <<c<< endl ;c -= ?a;cout << "Line 3 - -= 運算符實例，c 的值 = : " <<c<< endl ;c *= ?a;cout << "Line 4 - *= 運算符實例，c 的值 = : " <<c<< endl ;c /= ?a;cout << "Line 5 - /= 運算符實例，c 的值 = : " <<c<< endl ;c ?= 200;c %= ?a;cout << "Line 6 - %= 運算符實例，c 的值 = : " <<c<< endl ;c <<= ?2;cout << "Line 7 - <<= 運算符實例，c 的值 = : " <<c<< endl ;c >>= ?2; ? ?cout << "Line 8 - >>= 運算符實例，c 的值 = : " <<c<< endl ;c &= ?2;cout << "Line 9 - &= 運算符實例，c 的值 = : " <<c<< endl ;c ^= ?2;cout << "Line 10 - ^= 運算符實例，c 的值 = : " <<c<< endl ;c |= ?2;cout << "Line 11 - |= 運算符實例，c 的值 = : " <<c<< endl ;return 0; }

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

Line 1 - = ?運算符實例，c 的值 = 21 Line 2 - += 運算符實例，c 的值 = 42 Line 3 - -= 運算符實例，c 的值 = 21 Line 4 - *= 運算符實例，c 的值 = 441 Line 5 - /= 運算符實例，c 的值 = 21 Line 6 - %= 運算符實例，c 的值 = 11 Line 7 - <<= 運算符實例，c 的值 = 44 Line 8 - >>= 運算符實例，c 的值 = 11 Line 9 - &= 運算符實例，c 的值 = 2 Line 10 - ^= 運算符實例，c 的值 = 0 Line 11 - |= 運算符實例，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?	||?	從左到右?
條件?	?:?	從右到左?
賦值?	= += -= *= /= %=>>= <<= &= ^= |=?	從右到左?
逗號?	,?	從左到右?

實例

請看下面的實例，了解 C++ 中運算符的優先級。

復制并黏貼下面的 C++ 程序到 test.cpp 文件中，編譯并運行程序。

對比有括號和沒有括號時的區別，這將產生不同的結果。因為 ()、 /、 * 和 + 有不同的優先級，高優先級的操作符將優先計算。

#include <iostream>using namespace std;main() { ? int a = 20; ? int b = 10; ? int c = 15; ? int d = 5; ? int e;e = (a + b) * c / d; ? ? ?// ( 30 * 15 ) / 5cout << "(a + b) * c / d 的值是 " << e << endl ;e = ((a + b) * c) / d; ? ?// (30 * 15 ) / 5cout << "((a + b) * c) / d 的值是 " << e << endl ;e = (a + b) * (c / d); ? // (30) * (15/5)cout << "(a + b) * (c / d) 的值是 " << e << endl ;e = a + (b * c) / d; ? ? // ?20 + (150/5)cout << "a + (b * c) / d 的值是 " << e << endl ; ?return 0; }

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

(a + b) * c / d 的值是 90 ((a + b) * c) / d 的值是 90 (a + b) * (c / d) 的值是 90 a + (b * c) / d 的值是 50

-END-

猜你喜歡（點擊下劃線即可跳轉閱讀

9年FPGA工作經驗，轉行了，苦海無涯……

40+張最全Linux/C/C++思維導圖，收藏！

學C/C++語言，32個必備修養！

?最 后??

?

若覺得文章不錯，轉發分享，也是我們繼續更新的動力。

5T資源大放送！包括但不限于：C/C++，Linux，Python，Java，PHP，人工智能，PCB、FPGA、DSP、labview、單片機、等等！

在公眾號內回復「更多資源」，即可免費獲取，期待你的關注~

長按識別圖中二維碼關注

總結

以上是生活随笔為你收集整理的C++ 基础知识！初学者必看！的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。