学习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 <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;
}

输出结果为：文章来源地址https://www.toymoban.com/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

关系运算符

下面是 C++ 中常用的关系运算符及其描述

• 等于运算符 (==)：检查两个操作数是否相等，如果相等则返回 true，否则返回 false。
• 不等于运算符 (!=)：检查两个操作数是否不相等，如果不相等则返回 true，否则返回 false。
• 大于运算符 (>)：检查第一个操作数是否大于第二个操作数，如果是则返回 true，否则返回 false。
• 大于运算符 (>)：检查第一个操作数是否大于第二个操作数，如果是则返回 true，否则返回 false。
• 小于运算符 (<)：检查第一个操作数是否小于第二个操作数，如果是则返回 true，否则返回 false。
• 大于等于运算符 (>=)：检查第一个操作数是否大于等于第二个操作数，如果是则返回 true，否则返回 false。
• 小于等于运算符 (<=)：检查第一个操作数是否小于等于第二个操作数，如果是则返回 true，否则返回 false。

实例

#include <iostream>
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 <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，并使用逻辑运算符来检查它们的值。根据条件的不同结果，我们输出相应的消息。 

输出结果为：

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 <iostream>
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++ 支持的赋值运算符：

实例

#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;
}

输出结果为：

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 <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;
    
    // 强制转换运算符
    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

运算符优先级

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

实例

#include <iostream>
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

到了这里，关于学习c++的第四天的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！