学习c++的第四天
目录
运算符
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
杂项运算符
运算符优先级
运算符
算术运算符
算术运算符是 C++ 中用于执行基本算术操作的运算符。
- 加法运算符 (+)：将两个操作数相加。例如，A + B 将得到 30，因为 10 + 20 等于 30。
- 减法运算符 (-)：从第一个操作数中减去第二个操作数。例如，A - B 将得到 -10，因为 10 - 20 等于 -10。
- 乘法运算符 (*)：将两个操作数相乘。例如，A * B 将得到 200，因为 10 * 20 等于 200。
- 除法运算符 (/)：将第一个操作数除以第二个操作数。例如，B / A 将得到 2，因为 20 / 10 等于 2。请注意，如果操作数都是整数，则结果将取整数部分，而不是浮点数。
- 取模运算符 (%)：计算第一个操作数除以第二个操作数的余数。例如，B % A 将得到 0，因为 20 没有被 10 整除时余数为 0。
- 自增运算符 (++)：将整数值增加 1。例如，A++ 将使 A 的值从 10 增加到 11。
- 自减运算符 (--)：将整数值减少 1。例如，A-- 将使 A 的值从 10 减少到 9。
这些算术运算符可用于各种数据类型，包括整数和浮点数。
请注意，C++ 还支持复合赋值运算符，如 +=、-=、*=、/= 和 %=，它们可以将算术运算符与赋值运算符组合起来，简化代码编写。
实例
#include
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;
}
输出结果为：
A + B = 30
A - B = -10
A * B = 200
B / A = 2
B % A = 0
After A++, A = 11
After B--, B = 19关系运算符
下面是 C++ 中常用的关系运算符及其描述
- 等于运算符 (==)：检查两个操作数是否相等，如果相等则返回 true，否则返回 false。
- 不等于运算符 (!=)：检查两个操作数是否不相等，如果不相等则返回 true，否则返回 false。
- 大于运算符 (>)：检查第一个操作数是否大于第二个操作数，如果是则返回 true，否则返回 false。
- 大于运算符 (>)：检查第一个操作数是否大于第二个操作数，如果是则返回 true，否则返回 false。
- 小于运算符 (<)：检查第一个操作数是否小于第二个操作数，如果是则返回 true，否则返回 false。
- 大于等于运算符 (>=)：检查第一个操作数是否大于等于第二个操作数，如果是则返回 true，否则返回 false。
- 小于等于运算符 (<=)：检查第一个操作数是否小于等于第二个操作数，如果是则返回 true，否则返回 false。
实例
#include
using namespace std;
int main() {
int A = 10;
int B = 20;
// 示例：检查两个操作数的值是否相等
if (A == B) {
cout << "A等于B" << endl;
} else {
cout << "A不等于B" << endl;
}
// 示例：检查两个操作数的值是否不相等
if (A != B) {
cout << "A不等于B" << endl;
} else {
cout << "A等于B" << endl;
}
// 示例：检查左操作数的值是否大于右操作数的值
if (A > B) {
cout << "A大于B" << endl;
} else {
cout << "A不大于B" << endl;
}
// 示例：检查左操作数的值是否小于右操作数的值
if (A < B) {
cout << "A小于B" << endl;
} else {
cout << "A不小于B" << endl;
}
// 示例：检查左操作数的值是否大于或等于右操作数的值
if (A >= B) {
cout << "A大于等于B" << endl;
} else {
cout << "A小于B" << endl;
}
// 示例：检查左操作数的值是否小于或等于右操作数的值
if (A <= B) {
cout << "A小于等于B" << endl;
} else {
cout << "A大于B" << endl;
}
return 0;
}
输出结果为：
A不等于B
A不等于B
A不大于B
A小于B
A小于B
A小于等于B逻辑运算符
在C++中，逻辑运算符用于对布尔值进行操作和组合。常用的逻辑运算符有三个：逻辑与（&&），逻辑或（||）和逻辑非（!）。
逻辑与（&&）运算符：
- 用于检查多个条件是否同时为真。
- 当且仅当所有条件都为真时，整个表达式的结果才为真。
- 如果任何一个条件为假，则整个表达式的结果为假。
逻辑或（||）运算符：
- 用于检查多个条件是否有至少一个为真。
- 当任何一个条件为真时，整个表达式的结果就为真。
- 只有当所有条件都为假时，整个表达式的结果才为假。
逻辑非（!）运算符：
- 用于对单个条件进行取反操作。
- 如果条件为真，则取反后为假；如果条件为假，则取反后为真。
实例
#include
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，并使用逻辑运算符来检查它们的值。根据条件的不同结果，我们输出相应的消息。
输出结果为：
At least one of condition1 and condition2 is false.
At least one of condition1 and condition2 is true.
condition1 is true.位运算符
位运算符作用于位，通过逐位进行操作。下面是位运算符的一些常见示例及其描述：
按位与（&）运算符：
- 对两个操作数的每一个二进制位进行操作。
- 当且仅当两个操作数相应的二进制位都为1时，结果为1，否则为0。
按位或（|）运算符：
- 对两个操作数的每一个二进制位进行操作。
- 当两个操作数相应的二进制位中至少有一个为1时，结果为1，否则为0。
按位异或（^）运算符：
- 对两个操作数的每一个二进制位进行操作。
- 当且仅当两个操作数相应的二进制位不同时，结果为1，否则为0。
按位取反（~）运算符：
- 只对一个操作数的每一个二进制位进行操作。
- 结果是操作数的每一个二进制位取反。
左移位（<<）运算符：
- 将一个操作数的二进制位向左移动指定数量的位数。
- 向左移动时，右边的位用0填充。
右移位（>>）运算符：
- 将一个操作数的二进制位向右移动指定数量的位数。
- 向右移动时，左边的位用符号位填充。
假设变量A的值为60（二进制为0011 1100），变量B的值为13（二进制为0000 1101）。根据不同的运算符和操作数，以下是它们的运算结果：
A & B 的结果为12（二进制为0000 1100）
A | B 的结果为61（二进制为0011 1101）
A ^ B 的结果为49（二进制为0011 0001）
~A 的结果为-61（二进制为1100 0011，有符号二进制数的补码形式）
A << 2 的结果为240（二进制为1111 0000）
A >> 2 的结果为15（二进制为0000 1111）
以上是位运算符的常见用法。它们在处理位级操作时非常有用。
实例
以下是使用位运算符的示例代码：
#include
using namespace std;
int main() {
int num1 = 5; // 二进制为101
int num2 = 9; // 二进制为1001
// 示例：按位与运算符
int result1 = num1 & num2;
cout << "num1 & num2 的结果为：" << result1 << endl; // 输出：1（二进制为001）
// 示例：按位或运算符
int result2 = num1 | num2;
cout << "num1 | num2 的结果为：" << result2 << endl; // 输出：13（二进制为1101）
// 示例：按位异或运算符
int result3 = num1 ^ num2;
cout << "num1 ^ num2 的结果为：" << result3 << endl; // 输出：12（二进制为1100）
// 示例：按位取反运算符
int result4 = ~num1;
cout << "~num1 的结果为：" << result4 << endl; // 输出：-6（二进制为11111111111111111111111111111010）
// 示例：左移位运算符
int result5 = num1 << 1;
cout << "num1 << 1 的结果为：" << result5 << endl; // 输出：10（二进制为1010）
// 示例：右移位运算符
int result6 = num2 >> 1;
cout << "num2 >> 1 的结果为：" << result6 << endl; // 输出：4（二进制为100）
return 0;
}
赋值运算符
下表列出了 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 |
实例
#include
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;
}
输出结果为：
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 运算符用于获取变量或类型的大小（以字节为单位）。例如，sizeof(int) 返回整数类型的大小。
- Condition ? X : Y：条件运算符是一种三元运算符，根据条件的真假选择返回不同的值。如果条件为真，则返回 X，否则返回 Y。例如，(a > b) ? a : b 将返回 a 或 b 中较大的值。
- , 逗号运算符：逗号运算符用于顺序执行一系列表达式，并返回最后一个表达式的值。在多个表达式之间使用逗号表示它们按顺序执行。例如，int x = (a = 1, a + 2)，逗号运算符会先执行 a = 1，然后执行 a + 2，将结果赋给 x。
- .（点）和 ->（箭头）：这两个运算符用于访问类、结构体和共用体的成员。. 运算符用于直接访问已知对象的成员，而 -> 运算符用于通过指针访问对象的成员。例如，obj.member 和 ptr->member。
- Cast 强制转换运算符：强制转换运算符用于将一种数据类型转换为另一种数据类型。可以使用不同的强制转换操作符进行类型转换，例如 int(2.2) 将浮点数转换为整数。
- & 指针运算符：& 运算符用于获取变量的地址，并返回指向该变量的指针。例如，int* ptr = &a 将 a 的地址赋给指针 ptr。
- * 指针运算符：* 运算符用于解引用指针，获取指针所指向的对象的值。例如，int value = *ptr 将获取指针 ptr 所指向的对象的值。
这些运算符在 C++ 编程中广泛使用，对于正确的数据处理和操作是至关重要的。
实例
#include
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;
// 强制转换运算符
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 类型的大小。
- 使用条件运算符根据条件选择较大的值。
- 使用逗号运算符执行多个表达式，并返回最后一个表达式的值。
- 使用成员运算符访问结构体成员。
- 使用强制转换运算符将 double 类型转换为 int 类型。
- 使用指针运算符获取变量的地址，并解引用指针获取变量的值。
输出结果为：
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运算符优先级
下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 从左到右 |
实例
#include
using namespace std;
int main() {
int a = 10;
int b = 5;
int c = 2;
int result = a + b * c; // 先计算 b * c，再加上 a，结果为 20
cout << "a + b * c = " << result << endl;
result = (a + b) * c; // 先加 a 和 b，再乘以 c，结果为 30
cout << "(a + b) * c = " << result << endl;
bool x = true;
bool y = false;
bool result1 = x && y || !x; // 先计算逻辑与 x && y，再计算逻辑或 ||，最后取非 !x，结果为 true
cout << "x && y || !x = " << result1 << endl;
bool result2 = x || !y && x; // 先计算取非 !y，再计算逻辑与 !y && x，最后计算逻辑或 x || (!y && x)，结果为 true
cout << "x || !y && x = " << result2 << endl;
int num = 5;
int num2 = 10;
num += num2 * 2; // 先计算 num2 * 2，再将结果加到 num 上，等价于 num = num + (num2 * 2)，最后 num 的值为 25
cout << "num += num2 * 2: " << num << endl;
int value = (num > num2) ? num : num2; // 先比较 num 和 num2 的大小，根据条件返回较大的值，最后 value 的值为 25
cout << "value = " << value << endl;
return 0;
}
这段代码演示了以下操作：
- 展示了不同优先级运算符的计算顺序。
- 展示了逻辑运算符的使用，包括逻辑与（&&）和逻辑或（||）。
- 展示了赋值运算符的使用，包括复合赋值运算符（+=）。
- 展示了条件运算符（?:）的使用。
输出结果为：
a + b * c = 20
(a + b) * c = 30
x && y || !x = 0
x || !y && x = 1
num += num2 * 2: 25
value = 25