3 简单数据的处理

1 简单变量

1.1 变量定义的基本格式

在C++中，定义变量的基本格式遵循以下结构：

数据类型 变量名 = 初始值;

数据类型：指定变量的类型（如 int、float、char 等）。
变量名：符合命名规则的标识符，用于引用该变量。
初始值（可选）：为变量赋初始值，如果没有提供初始值，变量会包含未定义的值（特别是局部变量）。

1.2 基本数据类型

在C++中，基本数据类型（Fundamental Data Types）是构建所有其他类型的基础，C++的基本数据类型分为几大类：整型、字符型、浮点型、布尔型等。每种类型有不同的内存占用大小和存储能力。

补充：内存占用大小

在C++中，不同的数据类型占用的内存大小（即内存占用大小）依赖于编译器和系统架构（如32位或64位系统）。

内存占用大小的单位通常以“字节（Byte）”为基础，并且根据不同的数量级有更大的单位。以下是内存占用大小的常见单位及其关系：

1.2.1 常见内存单位

位（bit，b）：最小的存储单位，表示0或1。
字节（Byte，B）：1字节等于8位（bit），通常是计算机存储的基本单位。
千字节（Kilobyte，KB）：1KB等于1024字节（在计算机科学中，基于二进制，因此使用1024而不是1000）。
兆字节（Megabyte，MB）：1MB等于1024千字节（KB）。
吉字节（Gigabyte，GB）：1GB等于1024兆字节（MB）。
太字节（Terabyte，TB）：1TB等于1024吉字节（GB）。
拍字节（Petabyte，PB）：1PB等于1024太字节（TB）。

单位总结

单位	简写	大小关系
位	b	1 bit = 0 或 1
字节	B	1 Byte = 8 bits
千字节	KB	1 KB = 1024 B
兆字节	MB	1 MB = 1024 KB
吉字节	GB	1 GB = 1024 MB
太字节	TB	1 TB = 1024 GB
拍字节	PB	1 PB = 1024 TB

在计算机内存、磁盘存储和数据传输中，这些单位被广泛使用。

1.2.2 整数类型

用于存储整数值（没有小数部分），可以分为有符号和无符号类型。一般来说，整数类型的大小和范围取决于系统架构和编译器，但有些范围是标准化的。

int：标准整数类型，最常用的一种。通常占用4个字节（32位），表示范围约为 -2,147,483,648 到 2,147,483,647。
```
int x = 27; // 定义一个整型变量x，赋值为27
```
short int / short：短整型，通常占用2个字节，表示范围较小，约为 -32,768 到 32,767。
```
short y = 100; // 定义一个短整型变量y，赋值为100
```

long int / long：长整型，通常占用4或8个字节，范围比int更大。
```
long z = 1000000L; // 定义一个长整型变量z
```

其中 L 表示这是一个长整型常量。在C++中，当你想要明确表示某个数值为 long 类型时，可以在数字后面加上 L 或 l。例如 1000000L 明确表示这个数值是 long 类型的，而不是普通的 int 类型。

long int / long：长整型，通常占用4或8个字节，范围比int更大。
```
long z = 1000000L; // 定义一个长整型变量z
```

由于常量后面加了 LL，因此该数值被显式地标记为 long long 类型。

无符号整型（unsigned）：无符号类型只能表示非负整数。例如，unsigned int 取值范围为 0 到 4,294,967,295。
```
unsigned int u = 500; // 无符号整型变量u
```

1.2.3 字符类型

用于存储单个字符，实际上是整数类型，因为字符存储为其ASCII码值（在该小节后面解释）。

在C++中，字符类型的变量使用 char 数据类型定义，并且字符的值需要用单引号 (' ') 包围。单引号的作用是告诉编译器这是一个字符常量，而不是其他类型的数据。

字符变量的定义格式如下：

char 变量名 = '字符';

char：字符类型，占用1个字节，范围为 -128 到 127 或 0 到 255（无符号）。
```
char ch = 'A'; // 定义一个字符变量ch，值为'A'
```
signed char：有符号字符类型，范围 -128 到 127。
unsigned char：无符号字符类型，范围 0 到 255。
wchar_t：宽字符类型，用于存储更大的字符集（如Unicode字符）。宽字符的大小通常是2或4个字节，具体取决于实现。
```
wchar_t wide_ch = L'你'; // 定义一个宽字符
```

1.2.4 浮点类型

用于表示小数、分数等带有小数点的数值。浮点类型根据精度的不同，可以分为三种：

float：单精度浮点型，通常占用4个字节，精度大约为7位有效数字，范围约为 1.2E-38 到 3.4E+38。
```
float f = 3.14f; // 定义一个单精度浮点型变量f
```

使用 f 后缀明确浮点数常量为 float 类型，避免了默认为 double 的情况。

double：双精度浮点型，通常占用8个字节，精度大约为15位有效数字，范围约为 2.2E-308 到 1.7E+308。
```
double d = 3.14159265358979; // 定义一个双精度浮点型变量d
```
long double：扩展精度浮点型，通常占用16个字节，精度更高（实现依赖），用于表示非常大的或非常小的数。
```
long double ld = 2.718281828459045L; // 定义一个扩展精度浮点型变量ld
```
使用 L 后缀可以确保浮点常量被正确地解析为 long double 类型，以获得所需的精度。

1.2.5 布尔类型

用于存储逻辑值true或false，在C++中布尔类型为 bool，通常占用1个字节。

bool：表示布尔值，true 和 false。在内部，true 通常表示为1，false 表示为0。
```
bool flag = true; // 定义一个布尔型变量flag，值为true
```

1.2.6 空类型

void：表示没有数据类型，通常用于函数返回类型，表示该函数不返回任何值。
```
void function() { // 这个函数没有返回值 }
```

1.2.7 常量限定符

C++允许通过 const 关键字定义常量，即值不可修改的变量。

const int max_value = 100; // 定义一个常量整型变量

1.2.8 类型修饰符

C++中的一些基本类型可以使用修饰符来扩展其范围或缩小其内存占用：

signed：有符号类型，表示可以存储正数和负数。
unsigned：无符号类型，只能存储非负数。
short：短类型，减少整数的范围和内存占用。
long：长类型，增加整数的范围。

1.2.9 程序

在C++中，您可以使用 sizeof 操作符和 limits 头文件来确定基本数据类型的大小和范围。以下是如何使用这两种方法来检索系统中基本数据类型的最大长度（即字节数）和其他相关信息：

1. 使用 sizeof 操作符

sizeof 是一个编译时运算符，用于返回一个数据类型或对象的大小（以字节为单位）。

示例代码：

#include <iostream>
using namespace std;

int main() {
    cout << "Size of char: " << sizeof(char) << " byte(s)" << endl;
    cout << "Size of short: " << sizeof(short) << " byte(s)" << endl;
    cout << "Size of int: " << sizeof(int) << " byte(s)" << endl;
    cout << "Size of long: " << sizeof(long) << " byte(s)" << endl;
    cout << "Size of long long: " << sizeof(long long) << " byte(s)" << endl;
    cout << "Size of float: " << sizeof(float) << " byte(s)" << endl;
    cout << "Size of double: " << sizeof(double) << " byte(s)" << endl;
    cout << "Size of long double: " << sizeof(long double) << " byte(s)" << endl;

    return 0;
}

2. 使用 limits 头文件

limits 头文件提供了 std::numeric_limits 模板类，允许您查询基本数据类型的最大值、最小值以及其他属性。

示例代码：

#include <iostream>
#include <limits>
using namespace std;

int main() {
    cout << "char: " << endl;
    cout << "  min: " << numeric_limits<char>::min() << endl;
    cout << "  max: " << numeric_limits<char>::max() << endl;

    cout << "short: " << endl;
    cout << "  min: " << numeric_limits<short>::min() << endl;
    cout << "  max: " << numeric_limits<short>::max() << endl;

    cout << "int: " << endl;
    cout << "  min: " << numeric_limits<int>::min() << endl;
    cout << "  max: " << numeric_limits<int>::max() << endl;

    cout << "long: " << endl;
    cout << "  min: " << numeric_limits<long>::min() << endl;
    cout << "  max: " << numeric_limits<long>::max() << endl;

    cout << "long long: " << endl;
    cout << "  min: " << numeric_limits<long long>::min() << endl;
    cout << "  max: " << numeric_limits<long long>::max() << endl;

    cout << "float: " << endl;
    cout << "  min: " << numeric_limits<float>::min() << endl;
    cout << "  max: " << numeric_limits<float>::max() << endl;

    cout << "double: " << endl;
    cout << "  min: " << numeric_limits<double>::min() << endl;
    cout << "  max: " << numeric_limits<double>::max() << endl;

    cout << "long double: " << endl;
    cout << "  min: " << numeric_limits<long double>::min() << endl;
    cout << "  max: " << numeric_limits<long double>::max() << endl;

    return 0;
}

3. 示例解释

sizeof 操作符：

sizeof(char) 通常返回 1 字节。
sizeof(short)、sizeof(int)、sizeof(long) 和 sizeof(long long) 的值依赖于系统和编译器，通常 short 是 2 字节，int 是 4 字节，long 和 long long 可能是 4 字节或 8 字节。
浮点类型 float 通常是 4 字节，double 是 8 字节，long double 的大小也依赖于系统。

numeric_limits：

numeric_limits<T>::min() 返回数据类型 T 可以表示的最小值。
numeric_limits<T>::max() 返回数据类型 T 可以表示的最大值。
对于浮点类型，还可以查询 numeric_limits<T>::epsilon()（表示浮点数的最小精度）等其他属性。

以下是 <climits> 头文件中符号常量的展示：

符号常量	描述	示例值（可能因平台而异）
`CHAR_BIT`	每个 `char` 类型的位数	8
`CHAR_MIN`	`char` 类型的最小值	-128
`CHAR_MAX`	`char` 类型的最大值	127
`SCHAR_MIN`	`signed char` 类型的最小值	-128
`SCHAR_MAX`	`signed char` 类型的最大值	127
`UCHAR_MAX`	`unsigned char` 类型的最大值	255
`SHRT_MIN`	`short` 类型的最小值	-32,768
`SHRT_MAX`	`short` 类型的最大值	32,767
`USHRT_MAX`	`unsigned short` 类型的最大值	65,535
`INT_MIN`	`int` 类型的最小值	-2,147,483,648
`INT_MAX`	`int` 类型的最大值	2,147,483,647
`UINT_MAX`	`unsigned int` 类型的最大值	4,294,967,295
`LONG_MIN`	`long` 类型的最小值	-2,147,483,648 (32-bit)
`LONG_MAX`	`long` 类型的最大值	2,147,483,647 (32-bit)
`ULONG_MAX`	`unsigned long` 类型的最大值	4,294,967,295 (32-bit)
`LLONG_MIN`	`long long` 类型的最小值	-9,223,372,036,854,775,808
`LLONG_MAX`	`long long` 类型的最大值	9,223,372,036,854,775,807
`ULLONG_MAX`	`unsigned long long` 类型的最大值	18,446,744,073,709,551,615

总结

sizeof 操作符用于获取数据类型或对象的内存大小（以字节为单位）。
limits 头文件中的 std::numeric_limits 模板类用于获取基本数据类型的最小值、最大值以及其他特性。

这两种工具可以帮助你在编写代码时了解系统中各种基本数据类型的特性。

数据类型的大小与取值范围

类型	通常大小（字节）	取值范围或精度
`char`	1	`-128` 到 `127` 或 `0` 到 `255`
`int`	4	`-2,147,483,648` 到 `2,147,483,647`
`short`	2	`-32,768` 到 `32,767`
`long`	4 或 8	`-2,147,483,648` 到 `2,147,483,647`（4字节）
`long long`	8	`±9,223,372,036,854,775,807`
`float`	4	精度大约7位有效数字，范围 `1.2E-38` 到 `3.4E+38`
`double`	8	精度大约15位有效数字，范围 `2.2E-308` 到 `1.7E+308`
`long double`	8 或 16	取决于实现，精度和范围更大
`bool`	1	`true`（1）或 `false`（0）

这些基本数据类型是C++中进行数据存储和处理的基础，不同类型适合不同的应用场景。

2 变量名

在 C++ 中，变量名是用来标识变量的名称。选择合适的变量名有助于提高代码的可读性和可维护性。以下是有关变量名的一些基本规则和最佳实践：

2.1 命名规则

字母、数字和下划线：变量名可以包含字母（a-z、A-Z）、数字（0-9）和下划线（_）。
不能以数字开头：变量名不能以数字开头。例如，1variable 是非法的，而 variable1 是合法的。
区分大小写：C++ 是区分大小写的，因此 variable, Variable, 和 VARIABLE 是不同的变量名。
不能使用保留字：变量名不能是 C++ 的关键字或保留字，如 int, return, if 等。

2.2 命名约定

变量命名只要满足命名规则就是正确的，但是为了程序识别的方便，就有了以下约定：

描述性命名：变量名应能反映其用途或含义。例如，使用 totalAmount 而不是 ta。
驼峰式命名：常见的风格是使用驼峰式命名（camelCase），其中第一个单词的首字母小写，后续单词的首字母大写。例如，totalAmount, userName。
下划线分隔：另一种风格是使用下划线分隔单词（snake_case），所有字母小写，单词之间用下划线分隔。例如，total_amount, user_name。
常量命名：常量变量通常使用全大写字母，单词之间用下划线分隔。例如，MAX_VALUE, PI。

2.3 变量名示例

以下是一些合法和规范的变量名示例：

int age;               // 合法的变量名
float temperature;     // 合法的变量名
double userBalance;    // 合法的变量名
const int MAX_SIZE = 100; // 常量名
int maxScore = 0;      // 合法的变量名，驼峰式命名
int total_amount = 0;  // 合法的变量名，下划线分隔

2.4 变量名不应

过短：避免使用过于简短的变量名，如 a, x, y，除非它们的用途非常明确（如计数器）。
不具描述性：避免使用无意义的变量名，如 data1, temp, foo，这些名字不提供足够的信息。
与函数名或类型名冲突：避免使用与已有函数或类型名相同的变量名，以防混淆。

2.5 命名示例

int studentAge;       // 表示学生的年龄
float averageGrade;  // 表示平均成绩
bool isValidUser;    // 表示用户是否有效

2.6 变量名与作用域

局部变量：在函数内部定义的变量，只能在函数内部使用。
全局变量：在所有函数外部定义的变量，可以在整个程序中使用，但过多使用全局变量可能导致代码难以维护。
类成员变量：在类中定义的变量，用于存储类的状态。

总结

选择合适的变量名是编写可维护、易读代码的重要部分。遵循一致的命名约定、使用具有描述性的变量名，可以使代码更加清晰和易于理解。

3 C++算术运算符

C++中，算术运算符用于执行基本的数学运算。以下是常见的C++算术运算符：

3.1 算术运算符类别

加法运算符 (+)

用于两个数相加。

int a = 5; int b = 3; int result = a + b; // result = 8

减法运算符 (-)

用于一个数减去另一个数。

int a = 5; int b = 3; int result = a - b; // result = 2

乘法运算符 (*)

用于两个数相乘。

int a = 5; int b = 3; int result = a * b; // result = 15

除法运算符 (/)

用于两个数相除。如果参与运算的两个数都是整数，那么结果也是整数（舍弃小数部分）。

int a = 5; int b = 2; int result = a / b; // result = 2 （整数除法）

求模运算符 (%)

用于获取两个整数相除后的余数。只适用于整数。

int a = 5; int b = 2; int result = a % b; // result = 1

自增运算符 (++)

用于将变量的值增加1。可以分为前置自增和后置自增。

前置自增 (++a)：先将变量的值增加1，然后再使用它。
后置自增 (a++)：先使用变量当前的值，然后再将其增加1。

int a = 5; int b = ++a; // a = 6, b = 6 （前置自增） 
int c = a++; // a = 7, c = 6 （后置自增）

自减运算符 (--)

用于将变量的值减少1。和自增运算符类似，也有前置自减和后置自减。

前置自减 (--a)：先将变量的值减1，然后再使用它。
后置自减 (a--)：先使用变量当前的值，然后再将其减1。

int a = 5; int b = --a; // a = 4, b = 4 （前置自减） 
int c = a--; // a = 3, c = 4 （后置自减）

这些运算符是C++中用于执行数值运算的基础工具。

3.2 求模与除法

1.求模运算

求模运算用于计算两个数相除后的非负余数。与求余运算不同，求模运算的余数结果总是与除数（右操作数）的符号一致，且通常是非负数。在数学上，求模运算的定义通常要求余数保持非负。

在C++语言中使用 % 运算符来执行求余操作（其余数与被除数符号一致），但它并不是严格的求模运算。在某些数学场景中或者在特定的算法设计中，我们需要模运算来确保结果为非负数。

2.求模运算公式

当 a 为被除数，b 为除数时，求模运算 a % b 的结果为：

result = a - (a / b) * b

其中：

a 是被除数。
b 是除数。
余数的值是 a - n*b，其中 n 是 a / b 的向下取整（即floor(a / b)）。
结果总是非负数。

3.C++ 实现求模运算

因为C++的 % 运算符是求余运算，而不是严格的求模运算。如果你需要确保余数为非负数，可以根据以下方法进行求模操作：

int mod(int a, int b) {
    int result = a % b;
    if (result < 0) {
        result += abs(b);  // 将余数调整为正数
    }
    return result;
}

示例

正数的模运算：
```
int a = 10;
int b = 3;
int result = mod(a, b);  // result = 1
```
解释：10 / 3 = 3，余数为 1，不需要调整。
负数的模运算：
```
int a = -10;
int b = 3;
int result = mod(a, b);  // result = 2
```
解释：-10 / 3 = -4，余数 -1，但我们需要一个非负的余数，所以 -1 + 3 = 2。
负除数的模运算：
```
int a = 10;
int b = -3;
int result = mod(a, b);  // result = 1
```
解释：尽管 b 为负数，但模运算的结果依旧是非负的 1。

求模运算 vs 求余运算

运算类型	结果符号	示例 (a = -10, b = 3)
求模运算	余数为非负数	`mod(-10, 3) = 2`
求余运算	余数与被除数符号相同	`-10 % 3 = -1`

总结

求模运算保证余数是非负的，通常用于处理需要环形结构或循环的数据。
在C++中，如果你希望实现严格的模运算而不是求余，需要通过手动调整负余数来实现。

3.3 运算优先级与结合性

在C++中，运算符的优先级和结合性决定了表达式中运算符的执行顺序。优先级决定了多个运算符在同一表达式中哪个先执行，而结合性决定了当两个运算符具有相同优先级时，表达式是从左到右还是从右到左执行。

1. 运算符优先级

C++中的运算符优先级可以分为高优先级和低优先级。优先级越高，运算符就越早执行。下面是一些常见运算符的优先级（从高到低排列）：

优先级	运算符	说明
1	`()`、`[]`、`->`、`.`	圆括号、数组下标、成员访问
2	`++`、`--`	后置自增、自减
3	`++`、`--`、`+`、`-`、`!`、`~`	前置自增、自减、正负号、逻辑非、按位取反
4	`*`、`/`、`%`	乘法、除法、取模
5	`+`、`-`	加法、减法
6	`<<`、`>>`	左移、右移
7	`<`、`<=`、`>`、`>=`	比较运算符
8	`==`、`!=`	等于、不等于
9	`&`	按位与
10	`^`	按位异或
11	`	`
12	`&&`	逻辑与
13	`\|\|`	逻辑或
14	`?:`	条件运算符（三元运算符）
15	`=`、`+=`、`-=`、`*=`、`/=`、`%=`、`<<=`、`>>=`、`&=`、`^=`、`\|=`	赋值及复合赋值
16	`,`	逗号运算符

2. 运算符的结合性

结合性描述了当两个运算符具有相同优先级时，表达式是从左到右（左结合）还是从右到左（右结合）计算。

左结合性：

从左到右计算。多数运算符都具有左结合性。
```
int a = 5 - 3 + 2; // 等价于 (5 - 3) + 2
```
常见的左结合运算符包括：+、-、*、/、%、<<、>>、比较运算符（如 <, <=, > 等）以及逻辑运算符（如 &&, ||）。

右结合性：

从右到左计算。一般适用于赋值运算符和一些单目运算符。
```
int a; int b; a = b = 10; // 等价于 a = (b = 10)
```
常见的右结合运算符包括：赋值运算符（如 =, +=, -=, 等）、条件运算符 ?:、以及前置自增、自减运算符（如 ++, --）。

3. 运算符优先级和结合性实例

int a = 5 + 3 * 2;  // 乘法比加法优先级高，等价于 5 + (3 * 2) -> a = 11
int b = (5 + 3) * 2;  // 使用括号改变优先级，等价于 (5 + 3) * 2 -> b = 16

int c = 10;
c += 3 * 2;  // 先计算乘法，再执行复合赋值，等价于 c += 6 -> c = 16

int d = 5 - 3 + 2;  // 减法和加法具有相同优先级，按照左结合计算，
                    //等价于 (5 - 3) + 2 -> d = 4

4. 总结

优先级决定了运算符的计算顺序，优先级高的运算符会首先被执行。
结合性决定了当运算符优先级相同时的执行顺序。多数运算符是左结合的，但赋值类运算符是右结合的。
使用括号 () 可以显式控制运算顺序，避免优先级和结合性导致的计算错误。

3.4 类型转换

C++ 中的数据类型转换是指将一种数据类型的值转换为另一种数据类型的值。类型转换可以分为两类：

隐式类型转换（自动类型转换）
显式类型转换（手动类型转换）

3.4.1 隐式类型转换

隐式类型转换是由编译器自动执行的，当操作数的类型不同且需要进行转换时，编译器会自动进行转换。转换遵循一定的规则，通常是将“低精度”类型转换为“高精度”类型。

常见的隐式类型转换规则：

整型提升：较小的整数类型（如 char、short）在运算时会被提升为 int。
浮点数提升：整数类型可以自动转换为浮点数类型（如 int 到 float）。
精度提升：低精度类型（如 float）可以自动转换为高精度类型（如 double）。

示例：

#include <iostream>

int main() {
    int a = 10;
    double b = 3.5;

    // 隐式转换：a 被转换为 double，然后进行浮点数相加
    double result = a + b;

    std::cout << "Result: " << result << std::endl;  // 输出 13.5
    return 0;
}

在上面的例子中，a 被自动转换为 double，然后进行浮点数相加。

3.4.2 显式类型转换

显式类型转换（也称为强制类型转换）由程序员手动指定。C++ 提供了几种显式转换的方式：

1. C 风格的强制转换

最简单、最原始的强制转换方式，它的语法是：

(type)expression
(想要转换的类型)原数据

示例：

#include <iostream>

int main() {
    double pi = 3.14159;

    // C 风格的强制转换，将 double 转换为 int
    int intPi = (int)pi;

    std::cout << "intPi: " << intPi << std::endl;  // 输出 3
    return 0;
}

2. C++ 风格的强制转换

C++ 提供了更安全、更明确的类型转换方式，包括：

static_cast
dynamic_cast
const_cast
reinterpret_cast

1.static_cast

用于执行与编译时类型检查相关的转换，如基本数据类型之间的转换。

#include <iostream>

int main() {
    double pi = 3.14159;

    // 使用 static_cast 进行类型转换
    int intPi = static_cast<int>(pi);

    std::cout << "intPi: " << intPi << std::endl;  // 输出 3
    return 0;
}

2.dynamic_cast

主要用于在继承层次中安全地进行指针或引用的转换，通常用于多态对象之间的类型转换。它只能用于包含虚函数的类。

class Base {
    virtual void func() {}  // 必须包含虚函数
};

class Derived : public Base {};

int main() {
    Base *basePtr = new Derived();
    
    // 使用 dynamic_cast 进行类型转换
    Derived *derivedPtr = dynamic_cast<Derived*>(basePtr);

    if (derivedPtr) {
        // 转换成功
    } else {
        // 转换失败
    }

    delete basePtr;
    return 0;
}

3.const_cast

用于添加或移除对象的 const 属性。

void print(int *ptr) {
    // 修改指针指向的值
    *ptr = 10;
}

int main() {
    const int value = 5;

    // 使用 const_cast 进行类型转换
    print(const_cast<int*>(&value));

    return 0;
}

4.reinterpret_cast

用于进行低级别的、可能是不安全的类型转换。可以将指针转换为任意其他类型的指针。

int main() {
    int a = 65;

    // 使用 reinterpret_cast 进行类型转换
    char *charPtr = reinterpret_cast<char*>(&a);

    std::cout << "Character: " << *charPtr << std::endl;  // 输出 'A'，根据机器的字节序
    return 0;
}

3. 类型转换的注意事项

使用 static_cast、dynamic_cast 等 C++ 风格的强制转换通常比 C 风格的强制转换更安全、可读性更好。
dynamic_cast 只能用于包含虚函数的类，因为它依赖于运行时类型信息（RTTI）。
reinterpret_cast 是一种非常强大的转换方式，但使用不当可能导致未定义行为。

总结

隐式类型转换：编译器自动执行，通常由低精度类型转换为高精度类型。
显式类型转换：由程序员手动指定，有 C 风格和 C++ 风格。C++ 提供了 static_cast、dynamic_cast、const_cast 和 reinterpret_cast，以更好地控制类型转换的行为。

标签：字节,处理,C++,运算符,int,long,简单,类型,数据
From： https://blog.csdn.net/South_Rosefinch/article/details/142077662