目錄
運算符
算術(shù)運算符
關(guān)系運算符
邏輯運算符
位運算符
賦值運算符
雜項運算符
運算符優(yōu)先級
運算符
算術(shù)運算符
算術(shù)運算符是 C++ 中用于執(zhí)行基本算術(shù)操作的運算符。
- 加法運算符 (+)：將兩個操作數(shù)相加。例如，A + B 將得到 30，因為 10 + 20 等于 30。
- 減法運算符 (-)：從第一個操作數(shù)中減去第二個操作數(shù)。例如，A - B 將得到 -10，因為 10 - 20 等于 -10。
- 乘法運算符 (*)：將兩個操作數(shù)相乘。例如，A * B 將得到 200，因為 10 * 20 等于 200。
- 除法運算符 (/)：將第一個操作數(shù)除以第二個操作數(shù)。例如，B / A 將得到 2，因為 20 / 10 等于 2。請注意，如果操作數(shù)都是整數(shù)，則結(jié)果將取整數(shù)部分，而不是浮點數(shù)。
- 取模運算符 (%)：計算第一個操作數(shù)除以第二個操作數(shù)的余數(shù)。例如，B % A 將得到 0，因為 20 沒有被 10 整除時余數(shù)為 0。
- 自增運算符 (++)：將整數(shù)值增加 1。例如，A++ 將使 A 的值從 10 增加到 11。
- 自減運算符 (--)：將整數(shù)值減少 1。例如，A-- 將使 A 的值從 10 減少到 9。
這些算術(shù)運算符可用于各種數(shù)據(jù)類型，包括整數(shù)和浮點數(shù)。
請注意，C++ 還支持復(fù)合賦值運算符，如 +=、-=、*=、/= 和 %=，它們可以將算術(shù)運算符與賦值運算符組合起來，簡化代碼編寫。
實例
#include <iostream>
int main() {
int A = 10;
int B = 20;
// 加法運算符
int sum = A + B;
std::cout << "A + B = " << sum << std::endl;
// 減法運算符
int diff = A - B;
std::cout << "A - B = " << diff << std::endl;
// 乘法運算符
int product = A * B;
std::cout << "A * B = " << product << std::endl;
// 除法運算符
int quotient = B / A;
std::cout << "B / A = " << quotient << std::endl;
// 取模運算符
int remainder = B % A;
std::cout << "B % A = " << remainder << std::endl;
// 自增運算符
A++;
std::cout << "After A++, A = " << A << std::endl;
// 自減運算符
B--;
std::cout << "After B--, B = " << B << std::endl;
return 0;
}
輸出結(jié)果為：文章來源地址http://www.zghlxwxcb.cn/news/detail-739841.html
A + B = 30
A - B = -10
A * B = 200
B / A = 2
B % A = 0
After A++, A = 11
After B--, B = 19關(guān)系運算符
下面是 C++ 中常用的關(guān)系運算符及其描述
- 等于運算符 (==)：檢查兩個操作數(shù)是否相等，如果相等則返回 true，否則返回 false。
- 不等于運算符 (!=)：檢查兩個操作數(shù)是否不相等，如果不相等則返回 true，否則返回 false。
- 大于運算符 (>)：檢查第一個操作數(shù)是否大于第二個操作數(shù)，如果是則返回 true，否則返回 false。
- 大于運算符 (>)：檢查第一個操作數(shù)是否大于第二個操作數(shù)，如果是則返回 true，否則返回 false。
- 小于運算符 (<)：檢查第一個操作數(shù)是否小于第二個操作數(shù)，如果是則返回 true，否則返回 false。
- 大于等于運算符 (>=)：檢查第一個操作數(shù)是否大于等于第二個操作數(shù)，如果是則返回 true，否則返回 false。
- 小于等于運算符 (<=)：檢查第一個操作數(shù)是否小于等于第二個操作數(shù)，如果是則返回 true，否則返回 false。
實例
#include <iostream>
using namespace std;
int main() {
int A = 10;
int B = 20;
// 示例：檢查兩個操作數(shù)的值是否相等
if (A == B) {
cout << "A等于B" << endl;
} else {
cout << "A不等于B" << endl;
}
// 示例：檢查兩個操作數(shù)的值是否不相等
if (A != B) {
cout << "A不等于B" << endl;
} else {
cout << "A等于B" << endl;
}
// 示例：檢查左操作數(shù)的值是否大于右操作數(shù)的值
if (A > B) {
cout << "A大于B" << endl;
} else {
cout << "A不大于B" << endl;
}
// 示例：檢查左操作數(shù)的值是否小于右操作數(shù)的值
if (A < B) {
cout << "A小于B" << endl;
} else {
cout << "A不小于B" << endl;
}
// 示例：檢查左操作數(shù)的值是否大于或等于右操作數(shù)的值
if (A >= B) {
cout << "A大于等于B" << endl;
} else {
cout << "A小于B" << endl;
}
// 示例：檢查左操作數(shù)的值是否小于或等于右操作數(shù)的值
if (A <= B) {
cout << "A小于等于B" << endl;
} else {
cout << "A大于B" << endl;
}
return 0;
}
輸出結(jié)果為：
A不等于B
A不等于B
A不大于B
A小于B
A小于B
A小于等于B邏輯運算符
在C++中，邏輯運算符用于對布爾值進行操作和組合。常用的邏輯運算符有三個：邏輯與（&&），邏輯或（||）和邏輯非（!）。
邏輯與（&&）運算符：
- 用于檢查多個條件是否同時為真。
- 當(dāng)且僅當(dāng)所有條件都為真時，整個表達式的結(jié)果才為真。
- 如果任何一個條件為假，則整個表達式的結(jié)果為假。
邏輯或（||）運算符：
- 用于檢查多個條件是否有至少一個為真。
- 當(dāng)任何一個條件為真時，整個表達式的結(jié)果就為真。
- 只有當(dāng)所有條件都為假時，整個表達式的結(jié)果才為假。
邏輯非（!）運算符：
- 用于對單個條件進行取反操作。
- 如果條件為真，則取反后為假；如果條件為假，則取反后為真。
實例
#include <iostream>
using namespace std;
int main() {
bool condition1 = true;
bool condition2 = false;
// 示例：邏輯與運算符
if (condition1 && condition2) {
cout << "Both condition1 and condition2 are true." << endl;
}
else {
cout << "At least one of condition1 and condition2 is false." << endl;
}
// 示例：邏輯或運算符
if (condition1 || condition2) {
cout << "At least one of condition1 and condition2 is true." << endl;
}
else {
cout << "Both condition1 and condition2 are false." << endl;
}
// 示例：邏輯非運算符
if (!condition1) {
cout << "condition1 is false." << endl;
}
else {
cout << "condition1 is true." << endl;
}
return 0;
}
在這個示例中，我們定義了兩個布爾變量 condition1 和 condition2，并使用邏輯運算符來檢查它們的值。根據(jù)條件的不同結(jié)果，我們輸出相應(yīng)的消息。?
輸出結(jié)果為：
At least one of condition1 and condition2 is false.
At least one of condition1 and condition2 is true.
condition1 is true.位運算符
位運算符作用于位，通過逐位進行操作。下面是位運算符的一些常見示例及其描述：
按位與（&）運算符：
- 對兩個操作數(shù)的每一個二進制位進行操作。
- 當(dāng)且僅當(dāng)兩個操作數(shù)相應(yīng)的二進制位都為1時，結(jié)果為1，否則為0。
按位或（|）運算符：
- 對兩個操作數(shù)的每一個二進制位進行操作。
- 當(dāng)兩個操作數(shù)相應(yīng)的二進制位中至少有一個為1時，結(jié)果為1，否則為0。
按位異或（^）運算符：
- 對兩個操作數(shù)的每一個二進制位進行操作。
- 當(dāng)且僅當(dāng)兩個操作數(shù)相應(yīng)的二進制位不同時，結(jié)果為1，否則為0。
按位取反（~）運算符：
- 只對一個操作數(shù)的每一個二進制位進行操作。
- 結(jié)果是操作數(shù)的每一個二進制位取反。
左移位（<<）運算符：
- 將一個操作數(shù)的二進制位向左移動指定數(shù)量的位數(shù)。
- 向左移動時，右邊的位用0填充。
右移位（>>）運算符：
- 將一個操作數(shù)的二進制位向右移動指定數(shù)量的位數(shù)。
- 向右移動時，左邊的位用符號位填充。
假設(shè)變量A的值為60（二進制為0011 1100），變量B的值為13（二進制為0000 1101）。根據(jù)不同的運算符和操作數(shù)，以下是它們的運算結(jié)果：
A & B 的結(jié)果為12（二進制為0000 1100）
A | B 的結(jié)果為61（二進制為0011 1101）
A ^ B 的結(jié)果為49（二進制為0011 0001）
~A 的結(jié)果為-61（二進制為1100 0011，有符號二進制數(shù)的補碼形式）
A << 2 的結(jié)果為240（二進制為1111 0000）
A >> 2 的結(jié)果為15（二進制為0000 1111）
以上是位運算符的常見用法。它們在處理位級操作時非常有用。
實例
以下是使用位運算符的示例代碼：
#include <iostream>
using namespace std;
int main() {
int num1 = 5; // 二進制為101
int num2 = 9; // 二進制為1001
// 示例：按位與運算符
int result1 = num1 & num2;
cout << "num1 & num2 的結(jié)果為：" << result1 << endl; // 輸出：1（二進制為001）
// 示例：按位或運算符
int result2 = num1 | num2;
cout << "num1 | num2 的結(jié)果為：" << result2 << endl; // 輸出：13（二進制為1101）
// 示例：按位異或運算符
int result3 = num1 ^ num2;
cout << "num1 ^ num2 的結(jié)果為：" << result3 << endl; // 輸出：12（二進制為1100）
// 示例：按位取反運算符
int result4 = ~num1;
cout << "~num1 的結(jié)果為：" << result4 << endl; // 輸出：-6（二進制為11111111111111111111111111111010）
// 示例：左移位運算符
int result5 = num1 << 1;
cout << "num1 << 1 的結(jié)果為：" << result5 << endl; // 輸出：10（二進制為1010）
// 示例：右移位運算符
int result6 = num2 >> 1;
cout << "num2 >> 1 的結(jié)果為：" << result6 << endl; // 輸出：4（二進制為100）
return 0;
}
賦值運算符
下表列出了 C++ 支持的賦值運算符：
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符，把右邊操作數(shù)的值賦給左邊操作數(shù) | C = A + B 將把 A + B 的值賦給 C |
| += | 加且賦值運算符，把右邊操作數(shù)加上左邊操作數(shù)的結(jié)果賦值給左邊操作數(shù) | C += A 相當(dāng)于 C = C + A |
| -= | 減且賦值運算符，把左邊操作數(shù)減去右邊操作數(shù)的結(jié)果賦值給左邊操作數(shù) | C -= A 相當(dāng)于 C = C - A |
| *= | 乘且賦值運算符，把右邊操作數(shù)乘以左邊操作數(shù)的結(jié)果賦值給左邊操作數(shù) | C *= A 相當(dāng)于 C = C * A |
| /= | 除且賦值運算符，把左邊操作數(shù)除以右邊操作數(shù)的結(jié)果賦值給左邊操作數(shù) | C /= A 相當(dāng)于 C = C / A |
| %= | 求模且賦值運算符，求兩個操作數(shù)的模賦值給左邊操作數(shù) | C %= A 相當(dāng)于 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 |
實例
#include <iostream>
using namespace std;
int main() {
int a = 10, b = 5;
// 簡單賦值運算符
int c = a;
cout << "c = " << c << endl;
// 加且賦值運算符
c += a;
cout << "c += a: " << c << endl;
// 減且賦值運算符
c -= b;
cout << "c -= b: " << c << endl;
// 乘且賦值運算符
c *= a;
cout << "c *= a: " << c << endl;
// 除且賦值運算符
c /= b;
cout << "c /= b: " << c << endl;
// 求模且賦值運算符
c %= a;
cout << "c %= a: " << c << endl;
// 左移且賦值運算符
c <<= 2;
cout << "c <<= 2: " << c << endl;
// 右移且賦值運算符
c >>= 1;
cout << "c >>= 1: " << c << endl;
// 按位與且賦值運算符
c &= 3;
cout << "c &= 3: " << c << endl;
// 按位異或且賦值運算符
c ^= 7;
cout << "c ^= 7: " << c << endl;
// 按位或且賦值運算符
c |= 15;
cout << "c |= 15: " << c << endl;
return 0;
}
輸出結(jié)果為：
c = 10
c += a: 20
c -= b: 15
c *= a: 150
c /= b: 30
c %= a: 0
c <<= 2: 0
c >>= 1: 0
c &= 3: 0
c ^= 7: 7
c |= 15: 15雜項運算符
- sizeof：sizeof 運算符用于獲取變量或類型的大?。ㄒ宰止?jié)為單位）。例如，sizeof(int) 返回整數(shù)類型的大小。
- Condition ? X : Y：條件運算符是一種三元運算符，根據(jù)條件的真假選擇返回不同的值。如果條件為真，則返回 X，否則返回 Y。例如，(a > b) ? a : b 將返回 a 或 b 中較大的值。
- , 逗號運算符：逗號運算符用于順序執(zhí)行一系列表達式，并返回最后一個表達式的值。在多個表達式之間使用逗號表示它們按順序執(zhí)行。例如，int x = (a = 1, a + 2)，逗號運算符會先執(zhí)行 a = 1，然后執(zhí)行 a + 2，將結(jié)果賦給 x。
- .（點）和 ->（箭頭）：這兩個運算符用于訪問類、結(jié)構(gòu)體和共用體的成員。. 運算符用于直接訪問已知對象的成員，而 -> 運算符用于通過指針訪問對象的成員。例如，obj.member 和 ptr->member。
- Cast 強制轉(zhuǎn)換運算符：強制轉(zhuǎn)換運算符用于將一種數(shù)據(jù)類型轉(zhuǎn)換為另一種數(shù)據(jù)類型?？梢允褂貌煌膹娭妻D(zhuǎn)換操作符進行類型轉(zhuǎn)換，例如 int(2.2) 將浮點數(shù)轉(zhuǎn)換為整數(shù)。
- & 指針運算符：& 運算符用于獲取變量的地址，并返回指向該變量的指針。例如，int* ptr = &a 將 a 的地址賦給指針 ptr。
- ?* 指針運算符：* 運算符用于解引用指針，獲取指針?biāo)赶虻膶ο蟮闹?。例如，int value = *ptr 將獲取指針 ptr 所指向的對象的值。
這些運算符在 C++ 編程中廣泛使用，對于正確的數(shù)據(jù)處理和操作是至關(guān)重要的。
實例
#include <iostream>
using namespace std;
int main() {
int a = 10;
int b = 5;
int c = 0;
// sizeof 運算符
cout << "Size of int: " << sizeof(int) << " bytes" << endl;
// 條件運算符
c = (a > b) ? a : b;
cout << "Greater value: " << c << endl;
// 逗號運算符
int x = (c = 1, c + 2);
cout << "Comma operator result: " << x << endl;
// 成員運算符
struct Person {
string name;
int age;
};
Person person;
person.name = "John";
person.age = 25;
cout << "Person name: " << person.name << ", age: " << person.age << endl;
// 強制轉(zhuǎn)換運算符
double d = 2.2;
int i = int(d);
cout << "Double to int conversion: " << i << endl;
// 指針運算符
int* ptr = &a;
cout << "Address of a: " << ptr << endl;
cout << "Value at address: " << *ptr << endl;
return 0;
}
這段代碼演示了以下操作：
- 使用 sizeof 運算符獲取 int 類型的大小。
- 使用條件運算符根據(jù)條件選擇較大的值。
- 使用逗號運算符執(zhí)行多個表達式，并返回最后一個表達式的值。
- 使用成員運算符訪問結(jié)構(gòu)體成員。
- 使用強制轉(zhuǎn)換運算符將 double 類型轉(zhuǎn)換為 int 類型。
- 使用指針運算符獲取變量的地址，并解引用指針獲取變量的值。
輸出結(jié)果為：
Size of int: 4 bytes
Greater value: 10
Comma operator result: 3
Person name: John, age: 25
Double to int conversion: 2
Address of a: 000000D6246FF6C4
Value at address: 10運算符優(yōu)先級
下表將按運算符優(yōu)先級從高到低列出各個運算符，具有較高優(yōu)先級的運算符出現(xiàn)在表格的上面，具有較低優(yōu)先級的運算符出現(xiàn)在表格的下面。在表達式中，較高優(yōu)先級的運算符會優(yōu)先被計算。
| 類別? | 運算符? | 結(jié)合性? |
|---|---|---|
| 后綴? | () [] -> . ++ - - ? | 從左到右? |
| 一元? | + - ! ~ ++ - - (type)* & sizeof? | 從右到左? |
| 乘除? | * / %? | 從左到右? |
| 加減? | + -? | 從左到右? |
| 移位? | << >>? | 從左到右? |
| 關(guān)系? | < <= > >=? | 從左到右? |
| 相等? | == !=? | 從左到右? |
| 位與 AND? | &? | 從左到右? |
| 位異或 XOR? | ^? | 從左到右? |
| 位或 OR? | |? | 從左到右? |
| 邏輯與 AND? | &&? | 從左到右? |
| 邏輯或 OR? | ||? | 從左到右? |
| 條件? | ?:? | 從右到左? |
| 賦值? | = += -= *= /= %=>>= <<= &= ^= |=? | 從右到左? |
| 逗號? | ,? | 從左到右? |
實例
#include <iostream>
using namespace std;
int main() {
int a = 10;
int b = 5;
int c = 2;
int result = a + b * c; // 先計算 b * c，再加上 a，結(jié)果為 20
cout << "a + b * c = " << result << endl;
result = (a + b) * c; // 先加 a 和 b，再乘以 c，結(jié)果為 30
cout << "(a + b) * c = " << result << endl;
bool x = true;
bool y = false;
bool result1 = x && y || !x; // 先計算邏輯與 x && y，再計算邏輯或 ||，最后取非 !x，結(jié)果為 true
cout << "x && y || !x = " << result1 << endl;
bool result2 = x || !y && x; // 先計算取非 !y，再計算邏輯與 !y && x，最后計算邏輯或 x || (!y && x)，結(jié)果為 true
cout << "x || !y && x = " << result2 << endl;
int num = 5;
int num2 = 10;
num += num2 * 2; // 先計算 num2 * 2，再將結(jié)果加到 num 上，等價于 num = num + (num2 * 2)，最后 num 的值為 25
cout << "num += num2 * 2: " << num << endl;
int value = (num > num2) ? num : num2; // 先比較 num 和 num2 的大小，根據(jù)條件返回較大的值，最后 value 的值為 25
cout << "value = " << value << endl;
return 0;
}
這段代碼演示了以下操作：文章來源：http://www.zghlxwxcb.cn/news/detail-739841.html
- 展示了不同優(yōu)先級運算符的計算順序。
- 展示了邏輯運算符的使用，包括邏輯與（&&）和邏輯或（||）。
- 展示了賦值運算符的使用，包括復(fù)合賦值運算符（+=）。
- 展示了條件運算符（?:）的使用。
輸出結(jié)果為：
a + b * c = 20
(a + b) * c = 30
x && y || !x = 0
x || !y && x = 1
num += num2 * 2: 25
value = 25到了這里，關(guān)于學(xué)習(xí)c++的第四天的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
