C++基础：数据类型、变量与操作符全解析

# C++基础：数据类型、变量与操作符全解析 ## 1. 变量初始化 在C++中，我们可以使用花括号 `{}` 进行变量初始化。例如： ```cpp int main() { bool b{ true }; } ``` 上述代码声明了一个局部布尔变量 `b`，并将其初始化为 `true`。所有局部变量都应该进行初始化，访问未初始化的变量会导致未定义行为（Undefined Behavior，简称 UB）。 ## 2. 字符类型（char） ### 2.1 基本概念 字符类型 `char` 用于表示单个字符，如 `'a'`、`'Z'` 等，其大小固定为 1 字节。在C++中，字符字面量需用单引号括起来。以下是声明和初始化 `char` 变量的示例： ```cpp int main() { char c = 'a'; } ``` ### 2.2 输出字符变量 我们可以使用 `std::cout` 输出 `char` 变量的值： ```cpp #include <iostream> int main() { char c = 'a'; std::cout << "The value of variable c is: " << c; } ``` 输出结果为： ``` The value of variable c is: a ``` ### 2.3 修改字符变量的值 变量声明并初始化后，我们可以修改其值： ```cpp #include <iostream> int main() { char c = 'a'; std::cout << "The value of variable c is: " << c; c = 'B'; std::cout << " The new value of variable c is: " << c; } ``` 输出结果为： ``` The value of variable c is: a The new value of variable c is: B ``` ### 2.4 获取字符类型的大小 使用 `sizeof` 运算符可以获取 `char` 类型的大小： ```cpp #include <iostream> int main() { std::cout << "The size of type char is: " << sizeof(char) << " byte(s)"; } ``` 输出结果为： ``` The size of type char is: 1 byte(s) ``` ### 2.5 字符与整数的关系 在字符集中，每个字符都由一个整数表示。因此，我们既可以使用字符字面量，也可以使用数值字面量（在一定范围内）来初始化 `char` 变量。例如： ```cpp int main() { char c = 'a'; // 等同于: // char c = 97; } ``` 在 ASCII 表中，字符 `'a'` 对应的数值是 97。通常，我们更倾向于使用字符字面量来表示 `char` 对象的值。 ## 3. 整数类型（int） ### 3.1 基本概念 整数类型 `int` 用于存储整数值，包括正数和负数。以下是声明和初始化 `int` 变量的示例： ```cpp #include <iostream> int main() { int x = 123; int y = -256; std::cout << "The value of x is: " << x << ", the value of y is: " << y; } ``` 输出结果为： ``` The value of x is: 123, the value of y is: -256 ``` ### 3.2 整数类型的大小 `int` 类型的大小通常为 4 字节。我们也可以使用另一个变量来初始化一个 `int` 变量，此时会复制该变量的值，但它们在内存中是两个独立的对象。示例如下： ```cpp #include <iostream> int main() { int x = 123; int y = x; std::cout << "The value of x is: " << x << ", the value of y is: " << y; // x 为 123 // y 为 123 x = 456; std::cout << "The value of x is: " << x << ", the value of y is: " << y; // x 现在为 456 // y 仍然为 123 } ``` 输出结果为： ``` The value of x is: 123, the value of y is: 123The value of x is: 456, the value of y is: 123 ``` ### 3.3 整数字面量 整数字面量可以是十进制、八进制或十六进制。八进制字面量以 `0` 开头，十六进制字面量以 `0x` 开头。示例如下： ```cpp int main() { int x = 10; // 十进制字面量 int y = 012; // 八进制字面量 int z = 0xA; // 十六进制字面量 } ``` 上述三个变量都被初始化为 10，只是使用了不同的整数字面量表示。通常，我们更常用十进制字面量。 ## 4. 浮点类型 C++ 中有三种浮点类型：`float`、`double` 和 `long double`。我们主要使用 `double` 类型（双精度）来存储浮点值或实数。示例如下： ```cpp #include <iostream> int main() { double d = 3.14; std::cout << "The value of d is: " << d; } ``` 输出结果为： ``` The value of d is: 3.14 ``` 一些浮点字面量的示例如下： ```cpp int main() { double x = 213.456; double y = 1.; double z = 0.15; double w = .15; double d = 3.14e10; } ``` ## 5. void 类型 `void` 类型表示没有值。虽然我们不能创建 `void` 类型的对象，但可以有返回值为 `void` 的函数，即不返回值的函数。此外，还有 `void*` 类型的指针。关于指针和函数的更多内容将在后续介绍。 ## 6. 类型修饰符 类型可以有修饰符，常见的修饰符包括 `signed` 和 `unsigned`。`signed`（默认省略时为该修饰符）表示类型可以存储正数和负数，`unsigned` 表示类型为无符号表示。其他修饰符会影响类型的大小，`short` 表示类型宽度至少为 16 位，`long` 表示类型宽度至少为 32 位。我们还可以组合使用这些修饰符，示例如下： ```cpp #include <iostream> int main() { unsigned long int x = 4294967295; std::cout << "The value of an unsigned long integer variable is: " << x; } ``` 输出结果为： ``` The value of an unsigned long integer variable is: 4294967295 ``` `int` 类型默认是有符号的。 ## 7. 变量声明、定义和初始化 ### 7.1 变量声明 在当前作用域中引入一个名称称为声明。声明时，我们需要在变量名前加上类型名。示例如下： ```cpp int main() { char c; int x; double d; } ``` 我们也可以在同一行声明多个变量： ```cpp int main() { int x, y, z; } ``` ### 7.2 变量初始化 如果对象有初始值，则称为初始化。我们可以通过多种方式初始化对象，示例如下： ```cpp int main() { int x = 123; int y{ 123 }; int z = { 123 }; } ``` ### 7.3 变量定义 变量定义是为一个名称在内存中设置一个值，确保我们可以在程序中访问和使用该名称。简单来说，变量定义是声明后紧接着进行初始化，并以分号结尾。定义也是一种声明。示例如下： ```cpp int main() { char c = 'a'; int x = 123; double d = 456.78; } ``` ## 8. 操作符 ### 8.1 赋值操作符（=） 赋值操作符 `=` 用于将一个值赋给变量或对象。示例如下： ```cpp int main() { char mychar = 'c'; // 定义一个 char 变量 mychar mychar = 'd'; // 为 mychar 赋一个新值 int x = 123; // 定义一个整数变量 x x = 456; // 为 x 赋一个新值 int y = 789; // 定义一个新的整数变量 y y = x; // 将 x 的值赋给 y } ``` ### 8.2 算术操作符 我们可以使用算术操作符进行算术运算，常见的算术操作符包括： | 操作符 | 描述 | | ---- | ---- | | + | 加法 | | - | 减法 | | * | 乘法 | | / | 除法 | | % | 取模 | 示例如下： ```cpp #include <iostream> int main() { int x = 123; int y = 456; int result = x + y; // 加法 result = x - y; // 减法 result = x * y; // 乘法 result = x / y; // 除法 std::cout << "The result is: " << result << '\n'; } ``` 输出结果为： ``` The result is: 0 ``` 在整数除法中，如果两个操作数都是整数，结果会向零截断。如果我们需要浮点结果，需要使用 `double` 类型，并确保至少有一个操作数为 `double` 类型。示例如下： ```cpp #include <iostream> int main() { int x = 123; double y = 456.0; double result = x / y; std::cout << "The division result is: " << result << '\n'; } ``` 输出结果为： ``` The division result is: 0.269737 ``` ### 8.3 复合赋值操作符 复合赋值操作符允许我们使用一个操作符同时进行算术运算和赋值操作，常见的复合赋值操作符包括： | 操作符 | 描述 | | ---- | ---- | | += | 复合加法 | | -= | 复合减法 | | *= | 复合乘法 | | /= | 复合除法 | | %= | 复合取模 | 示例如下： ```cpp #include <iostream> int main() { int x = 123; x += 10; // 等同于 x = x + 10 x -= 10; // 等同于 x = x - 10 x *= 2; // 等同于 x = x * 2 x /= 3; // 等同于 x = x / 3 std::cout << "The value of x is: " << x; } ``` 输出结果为： ``` The value of x is: 82 ``` ### 8.4 自增/自减操作符 自增/自减操作符用于增加或减少对象的值，包括前置和后置两种形式： | 操作符 | 描述 | | ---- | ---- | | ++x | 前置自增操作符 | | x++ | 后置自增操作符 | | --x | 前置自减操作符 | | x-- | 后置自减操作符 | 示例如下： ```cpp #include <iostream> int main() { int x = 123; x++; // 给 x 的值加 1 ++x; // 给 x 的值加 1 --x; // 将 x 的值减 1 x--; // 将 x 的值减 1 std::cout << "The value of x is: " << x; } ``` 输出结果为： ``` The value of x is: 123 ``` 前置自增和后置自增操作符都会给对象的值加 1，前置自减和后置自减操作符都会给对象的值减 1。它们的区别在于，前置操作符先加/减 1，再在表达式中计算/访问变量；后置操作符先计算/访问变量，再进行加/减 1 操作。对于后续语句来说，对象的值是相同的，只是在表达式中的执行时机不同。 ## 9. 标准输入 C++ 提供了从用户获取输入的功能，标准输入可以看作是我们的键盘。以下是一个简单的示例，接受一个整数并将其输出： ```cpp #include <iostream> int main() { std::cout << "Please enter a number and press enter: "; int x = 0; std::cin >> x; std::cout << "You entered: " << x; } ``` 可能的输出如下： ``` Please enter a number and press enter: 123 You entered: 123 ``` `std::cin` 是标准输入流，使用流提取操作符 `>>` 将读取的内容提取到我们的变量中。`std::cin >> x;` 语句表示从标准输入读取数据到变量 `x` 中。`cin` 对象位于 `std` 命名空间中，`std::cout <<` 用于输出数据到屏幕，`std::cin >>` 用于从键盘输入数据。 我们可以使用多个 `>>` 操作符接受多个值： ```cpp #include <iostream> int main() { std::cout << "Please enter two numbers separated by a space and press enter: "; int x = 0; int y = 0; std::cin >> x >> y; std::cout << "You entered: " << x << " and " << y; } ``` 可能的输出如下： ``` Please enter two numbers separated by a space and press enter: 123 456 You entered: 123 and 456 ``` 我们还可以接受不同类型的值： ```cpp #include <iostream> int main() { std::cout << "Please enter a character, an integer, and a double: "; char c = 0; int x = 0; double d = 0.0; std::cin >> c >> x >> d; std::cout << "You entered: " << c << ", " << x << " and " << d; } ``` 可能的输出如下： ``` Please enter a character, an integer, and a double: A 123 3.14 You entered: A, 123 and 3.14 ``` 下面是一个简单的流程图，展示了标准输入的基本流程： ```mermaid graph TD; A[开始] --> B[提示用户输入]; B --> C[读取输入到变量]; C --> D[输出变量的值]; D --> E[结束]; ``` ## 10. 练习 ### 10.1 Hello World 和注释 编写一个包含注释的程序，输出 “Hello World.” 和 “C++ rocks!”。 ```cpp #include <iostream> int main() { // 这是一个注释 std::cout << "Hello World." << '\n'; std::cout << "C++ rocks!"; } ``` 输出结果： ``` Hello World. C++ rocks! ``` ### 10.2 声明变量 编写一个程序，在 `main` 函数中声明三个变量，分别为 `char`、`int` 和 `double` 类型。 ```cpp int main() { char mychar; int myint; double mydouble; } ``` ### 10.3 定义变量 编写一个程序，在 `main` 函数中定义三个变量，分别为 `char`、`int` 和 `double` 类型，并赋予任意初始值。 ```cpp int main() { char mychar = 'a'; int myint = 123; double mydouble = 456.78; } ``` ### 10.4 初始化变量 编写一个程序，在 `main` 函数中定义三个变量，分别为 `char`、`int` 和 `double` 类型，使用初始化列表进行初始化，并输出这些变量的值。 ```cpp #include <iostream> int main() { char mychar{ 'a' }; int myint{ 123 }; double mydouble{ 456.78 }; std::cout << "The value of a char variable is: " << mychar << '\n'; std::cout << "The value of an int variable is: " << myint << '\n'; std::cout << "The value of a double variable is: " << mydouble << '\n'; } ``` 输出结果： ``` The value of a char variable is: a The value of an int variable is: 123 The value of a double variable is: 456.78 ``` ### 10.5 标准输入 编写一个程序，从标准输入接受一个整数，并将其输出。 ```cpp #include <iostream> int main() { std::cout << "Please enter a number: "; int x; std::cin >> x; std::cout << "You entered: " << x; } ``` 可能的输出结果： ``` Please enter a number: 123 You entered: 123 ``` ### 10.6 两个输入 编写一个程序，从标准输入接受两个整数，并将它们输出。 ```cpp #include <iostream> int main() { std::cout << "Please enter two integer numbers: "; int x; int y; std::cin >> x >> y; std::cout << "You entered: " << x << " and " << y; } ``` 可能的输出结果： ``` Please enter two integer numbers: 123 456 You entered: 123 and 456 ``` ### 10.7 多个输入 编写一个程序，从标准输入接受一个 `char`、一个 `int` 和一个 `double` 类型的值，并将它们输出。 ```cpp #include <iostream> int main() { std::cout << "Please enter a char, an int, and a double: "; char c; int x; double d; std::cin >> c >> x >> d; std::cout << "You entered: " << c << ", " << x << ", and " << d; } ``` 可能的输出结果： ``` Please enter a char, an int, and a double: A 123 456.789 You entered: A, 123, and 456.789 ``` ### 10.8 输入与算术运算 编写一个程序，从标准输入接受两个整数，将它们相加，并将结果赋给第三个整数，最后输出结果。 ```cpp #include <iostream> int main() { std::cout << "Please enter two integer numbers: "; int x; int y; std::cin >> x >> y; int result = x + y; std::cout << "The result is: " << result; } ``` 可能的输出结果： ``` Please enter two integer numbers: 10 20 The result is: 30 ``` ### 10.9 后置自增与复合赋值 编写一个程序，定义一个 `int` 变量 `x` 并初始化为 100，对其进行后置自增操作，然后使用复合赋值操作符加上 10，最后输出结果。 ```cpp #include <iostream> int main() { int x = 100; x++; x += 10; std::cout << "The result is: " << x; } ``` 输出结果： ``` The result is: 111 ``` ### 10.10 整数与浮点除法 编写一个程序，将 9 除以 2，将结果分别赋给一个 `int` 变量和一个 `double` 变量，然后将其中一个操作数改为 `double` 类型，观察浮点除法的不同结果，并输出这些结果。 ```cpp #include <iostream> int main() { int x = 9 / 2; std::cout << "The result is: " << x << '\n'; double d = 9 / 2; std::cout << "The result is: " << d << '\n'; d = 9.0 / 2; std::cout << "The result is: " << d; } ``` 输出结果： ``` The result is: 4 The result is: 4 The result is: 4.5 ``` ## 11. 数组 数组是相同类型对象的序列。我们可以按如下方式声明一个 `char` 类型的数组： ```cpp int main() { char arr[5]; } ``` 上述代码声明了一个包含五个字符的数组。如果要声明一个包含五个元素的 `int` 类型数组，可以这样写： ```cpp int main() { int arr[5]; } ``` 我们可以使用初始化列表 `{}` 来初始化数组： ```cpp int main() { int arr[5] = { 10, 20, 30, 40, 50 }; } ``` 在上述示例中，初始化列表 `{ 10, 20, 30, 40, 50 }` 用花括号括起来，值之间用逗号分隔。这个初始化列表将数组的元素依次初始化为列表中的值。第一个数组元素初始化为 10，第二个初始化为 20，以此类推，最后一个（第五个）元素的值为 50。 我们可以通过下标 `[]` 运算符和索引来访问数组的单个元素。数组的第一个元素的索引为 0，示例如下： ```cpp int main() { int arr[5] = { 10, 20, 30, 40, 50 }; arr[0] = 100; // 更改第一个数组元素的值 } ``` 由于数组的索引从 0 开始，而不是 1，所以最后一个数组元素的索引为 4： ```cpp int main() { int arr[5] = { 10, 20, 30, 40, 50 }; arr[4] = 500; // 更改最后一个数组元素的值 } ``` 因此，在声明数组时，我们指定要声明的元素数量，但在访问数组元素时，需要记住索引从 0 开始，到元素数量减 1 结束。在现代 C++ 中，我们应该优先使用 `std::array` 和 `std::vector` 容器，而不是原始数组。 下面是一个简单的流程图，展示了数组的基本操作流程： ```mermaid graph TD; A[声明数组] --> B[初始化数组]; B --> C[访问数组元素]; C --> D[修改数组元素的值]; D --> E[结束]; ``` ## 12. 指针 对象存储在内存中，到目前为止，我们学习了如何通过变量来访问和操作对象。另一种访问内存中对象的方式是通过指针。每个对象在内存中占用一定数量的字节，有类型和地址，这使得我们可以通过指针来访问对象。指针是一种可以保存特定对象地址的类型。为了便于说明，我们声明一个未使用的指针，它可以指向一个 `int` 对象： ```cpp int main() { int* p; } ``` 我们说 `p` 的类型是 `int*`。 要声明一个指向 `char` 对象的指针，我们声明一个 `char*` 类型的指针： ```cpp int main() { char* p; } ``` 在第一个示例中，我们声明了一个 `int*` 类型的指针。要让它指向内存中现有的 `int` 对象，我们使用取地址运算符 `&`。我们说 `p` 指向 `x`。 ```cpp int main() { int x = 123; int* p = &x; } ``` 在第二个示例中，我们声明了一个 `char*` 类型的指针，同样地： ```cpp int main() { char c = 'a'; char* p = &c; } ``` 要初始化一个不指向任何对象的指针，我们可以使用 `nullptr` 字面量： ```cpp int main() { char* p = nullptr; } ``` 此时，我们说 `p` 是一个空指针。 指针和其他类型的对象一样，也是变量/对象，它们的值是对象的地址，即对象存储的内存位置。要访问指针所指向对象中存储的值，我们需要对指针进行解引用。解引用是通过在指针（变量）名前加上解引用运算符 `*` 来完成的： ```cpp int main() { char c = 'a'; char* p = &c; char d = *p; } ``` 要输出解引用指针的值，我们可以使用以下代码： ```cpp #include <iostream> int main() { char c = 'a'; char* p = &c; std::cout << "The value of the dereferenced pointer is: " << *p; } ``` 输出结果： ``` The value of the dereferenced pointer is: a ``` 同样，对于整数指针，我们有： ```cpp #include <iostream> int main() { int x = 123; int* p = &x; std::cout << "The value of the dereferenced pointer is: " << *p; } ``` 输出结果： ``` The value of the dereferenced pointer is: 123 ``` 我们可以通过解引用指针来更改所指向对象的值： ```cpp #include <iostream> int main() { int x = 123; int* p = &x; *p = 456; // 更改所指向对象的值 std::cout << "The value of x is: " << x; } ``` 输出结果： ``` The value of x is: 456 ``` 我们将在讨论动态内存分配和对象生命周期等概念时，进一步探讨指针，尤其是智能指针。 下面是一个简单的流程图，展示了指针的基本操作流程： ```mermaid graph TD; A[声明指针] --> B[初始化指针指向对象]; B --> C[解引用指针获取对象值]; C --> D[通过指针修改对象值]; D --> E[结束]; ```