C++编程等级认证学习计划day2-2

一、基础算术表达式

1. 加法（+）

加法运算符用于将两个操作数相加，操作数可以是常量、变量或者表达式。在 C++ 中，适用于多种数据类型，比如整型、浮点型等。

#include <iostream>
using namespace std;

int main() {
    int num1 = 5;
    int num2 = 3;
    int sum = num1 + num2;  // 整型加法，将num1和num2相加的结果赋值给sum
    cout << "两整数相加的结果：" << sum << endl;

    double d1 = 2.5;
    double d2 = 1.5;
    double result = d1 + d2;  // 浮点型加法
    cout << "两浮点数相加的结果：" << result << endl;

    return 0;
}

2. 减法（-）

减法运算符用于求两个操作数的差值，同样可应用于整型、浮点型等数据类型。

#include <iostream>
using namespace std;

int main() {
    int a = 8;
    int b = 3;
    int diff = a - b;  // 整型减法
    cout << "两整数相减的结果：" << diff << endl;

    double x = 5.0;
    double y = 2.5;
    double sub_result = x - y;  // 浮点型减法
    cout << "两浮点数相减的结果：" << sub_result << endl;

    return 0;
}

3. 乘法（*）

乘法运算符用于计算两个操作数的乘积。

#include <iostream>
using namespace std;

int main() {
    int m = 4;
    int n = 6;
    int product = m * n;  // 整型乘法
    cout << "两整数相乘的结果：" << product << endl;

    double p = 3.0;
    double q = 2.0;
    double multi_result = p * q;  // 浮点型乘法
    cout << "两浮点数相乘的结果：" << multi_result << endl;

    return 0;
}

4. 除法（/）

• 对于整型数据类型，除法运算执行的是整除操作，即只取商的整数部分，舍去小数部分。
• 对于浮点型数据类型，则会得到精确的商，包含小数部分。

#include <iostream>
using namespace std;

int main() {
    int i = 10;
    int j = 3;
    int div_result = i / j;  // 整型整除，结果为3
    cout << "整型整除的结果：" << div_result << endl;

    double f1 = 10.0;
    double f2 = 3.0;
    double f_div_result = f1 / f2;  // 浮点型除法，结果约为3.333333
    cout << "浮点型除法的结果：" << f_div_result << endl;

    return 0;
}

5. 整除（/ 在整型运算中的体现，前面已举例说明）

当两个整型数进行除法运算时，就实现了整除操作，如 7 / 2 的结果是 3（舍去了小数部分 0.5）。

6. 求余（%）

求余运算符也叫取模运算符，用于获取两个整数相除后的余数，它的操作数必须是整型。

#include <iostream>
using namespace std;

int main() {
    int num3 = 10;
    int num4 = 3;
    int remainder = num3 % num4;  // 求10除以3的余数，结果为1
    cout << "两整数求余的结果：" << remainder << endl;

    return 0;
}

二、逻辑运算

1. 与（&&）

逻辑与运算符连接两个表达式，只有当两个表达式的值都为 true（在 C++ 中，非零值表示 true，零值表示 false）时，整个逻辑与表达式的值才为 true，否则为 false。

#include <iostream>
using namespace std;

int main() {
    bool a = true;
    bool b = false;
    bool result_and = a && b;  // 因为b为false，所以结果为false
    cout << "逻辑与运算的结果：" << (result_and? "true" : "false") << endl;

    int num5 = 5;
    int num6 = 0;
    bool condition1 = num5 > 0 && num6 > 0;  // 第一个条件为true，但第二个为false，整体为false
    cout << "另一个逻辑与运算的结果：" << (condition1? "true" : "false") << endl;

    return 0;
}

2. 或（||）

逻辑或运算符连接两个表达式，只要两个表达式中有一个的值为 true，整个逻辑或表达式的值就为 true，只有当两个表达式的值都为 false 时，结果才为 false。

#include <iostream>
using namespace std;

int main() {
    bool c = true;
    bool d = false;
    bool result_or = c || d;  // 因为c为true，所以结果为true
    cout << "逻辑或运算的结果：" << (result_or? "true" : "false") << endl;

    int num7 = 0;
    int num8 = 0;
    bool condition2 = num7 > 0 || num8 > 0;  // 两个条件都为false，整体为false
    cout << "另一个逻辑或运算的结果：" << (condition2? "true" : "false") << endl;

    return 0;
}

3. 非（!）

逻辑非运算符用于对单个表达式取反，若表达式的值原本为 true，则取反后为 false；若原本为 false，则取反后为 true。

#include <iostream>
using namespace std;

int main() {
    bool e = true;
    bool result_not =!e;  // 对e取反，结果为false
    cout << "逻辑非运算的结果：" << (result_not? "true" : "false") << endl;

    int num9 = 0;
    bool condition3 =!(num9 > 0);  // num9大于0为false，取反后为true
    cout << "另一个逻辑非运算的结果：" << (condition3? "true" : "false") << endl;

    return 0;
}

三、关系运算

1. 大于（>）

用于判断左边的操作数是否大于右边的操作数，返回值为布尔类型（true 或 false）。

#include <iostream>
using namespace std;

int main() {
    int num10 = 5;
    int num11 = 3;
    bool greater = num10 > num11;  // 5大于3，结果为true
    cout << "大于关系运算的结果：" << (greater? "true" : "false") << endl;

    return 0;
}

2. 大于等于（>=）

判断左边的操作数是否大于等于右边的操作数。

#include <iostream>
using namespace std;

int main() {
    int num12 = 5;
    int num13 = 5;
    bool greater_equal = num12 >= num13;  // 5等于5，满足大于等于关系，结果为true
    cout << "大于等于关系运算的结果：" << (greater_equal? "true" : "false") << endl;

    return 0;
}

3. 小于（<）

判断左边操作数是否小于右边操作数。

#include <iostream>
using namespace std;

int main() {
    int num14 = 3;
    int num15 = 5;
    bool less = num14 < num15;  // 3小于5，结果为true
    cout << "小于关系运算的结果：" << (less? "true" : "false") << endl;

    return 0;
}

4. 小于等于（<=）

判断左边操作数是否小于等于右边操作数。

#include <iostream>
using namespace std;

int main() {
    int num16 = 5;
    int num17 = 5;
    bool less_equal = num16 <= num17;  // 5等于5，满足小于等于关系，结果为true
    cout << "小于等于关系运算的结果：" << (less_equal? "true" : "false") << endl;

    return 0;
}

5. 等于（==）

判断左右两边的操作数是否相等，注意与赋值运算符（=）区分开。

#include <iostream>
using namespace std;

int main() {
    int num18 = 5;
    int num19 = 5;
    bool equal = num18 == num19;  // 两个数相等，结果为true
    cout << "等于关系运算的结果：" << (equal? "true" : "false") << endl;

    return 0;
}

6. 不等于（!=）

判断左右两边的操作数是否不相等，与等于关系运算正好相反。

#include <iostream>
using namespace std;

int main() {
    int num20 = 5;
    int num21 = 3;
    bool not_equal = num20!= num21;  // 5和3不相等，结果为true
    cout << "不等于关系运算的结果：" << (not_equal? "true" : "false") << endl;

    return 0;
}

四、基础的数据类型

1. 整型（int）

用于存储整数类型的数据，在不同的操作系统和编译器环境下，int 类型所占字节数可能不同，但通常是 4 个字节（32 位），可以表示一定范围的整数（例如 -2147483648 到 2147483647）。

#include <iostream>
using namespace std;

int main() {
    int myInt = 10;  // 定义并初始化一个整型变量
    cout << "整型变量的值：" << myInt << endl;

    int anotherInt;
    anotherInt = 20;  // 先定义，后赋值
    cout << "另一个整型变量的值：" << anotherInt << endl;

    return 0;
}

2. 实数型（主要包括 float 和 double）

• float：单精度浮点型，通常占 4 个字节，能表示一定精度的小数，但精度相对 double 较低，适用于对内存占用要求较严格且精度要求不是极高的场景。
• double：双精度浮点型，一般占 8 个字节，能表示更精确的小数，常用于需要高精度数值计算的场合。

#include <iostream>
using namespace std;

int main() {
    float myFloat = 3.14f;  // 定义并初始化单精度浮点型变量，注意后面要加 'f' 后缀
    cout << "单精度浮点型变量的值：" << myFloat << endl;

    double myDouble = 3.1415926;  // 定义并初始化双精度浮点型变量
    cout << "双精度浮点型变量的值：" << myDouble << endl;

    return 0;
}

3. 字符型（char）

用于存储单个字符，在内存中占 1 个字节，字符需要用单引号括起来表示，本质上存储的是字符对应的 ASCII 码值（在 C++ 中扩展了对 Unicode 等多字节字符编码的支持，但基础使用还是基于 ASCII 常见情况）。

#include <iostream>
using namespace std;

int main() {
    char myChar = 'A';  // 定义并初始化一个字符型变量
    cout << "字符型变量的值：" << myChar << endl;

    char anotherChar = 65;  // 也可以通过ASCII码值来赋值，65对应的字符就是 'A'
    cout << "另一个字符型变量的值：" << anotherChar << endl;

    return 0;
}

4. 布尔型（bool）

布尔型只有两个取值，true（表示真，在内存中实际存储的值通常为 1）和 false（表示假，内存中实际存储的值通常为 0），常用于表示条件判断的结果等逻辑情况。

#include <iostream>
using namespace std;

int main() {
    bool myBool = true;  // 定义并初始化一个布尔型变量
    cout << "布尔型变量的值：" << (myBool? "true" : "false") << endl;

    bool anotherBool = false;
    cout << "另一个布尔型变量的值：" << (anotherBool? "true" : "false") << endl;

    return 0;
}