【C++基础语法】02 C++ 基本数据类型及其转换

关注

原创 2022-04-22 23:07:38 1k 阅读 AI 写同款· GEO 优化 ›

【C++】使用 yaml-cpp 库操作 YAML 配置文件有利于我们灵活配置工程，解决大量重复劳动，也方便调试。YAML 是一种人类可读的数据序列化格式，它使用缩进和特定的符号来表示数据结构。在本文中，我们将详细介绍如何在 C++ 中使用yaml-cpp库来解析和生成 YAML 格式的数据。阅读详情

再次说明，本专栏文章采用最少必要知识原则，只讲解必要知识，让青少年，先上手编程，再上道。

文章采用更简单易懂的文字，不涉及很多的专有名词，部分举例有失精准。一切为了开始入门编程。

请先复习上文 - 重点回顾 - 部分内容。

基本数据类型

变量：是存储信息的容器。根据所需存储的信息不同，可选择不同类型的容器。
变量类型：也就是变量的数据类型，常见的基本数据类型有：整数类型、浮点数类型、字符类型、布尔类型。

不同数据类型的变量，所能存储的信息不同。

整数类型：包含正整数、0、负整数。比如：-1、-2、0、1、2 等
浮点数类型：就是数学里的小数。比如：1.0、3.14、-9.88 等
字符类型：单引号括起来的单个字符。比如： 26 个大小写字母、数字　０-9、及其它特殊字符 & * % ^ $ # @ ! ~ 等。
布尔类型：仅有两个值，代表逻辑真的 true、逻辑假的 false。

任务1：注意区分，0 是整数， '0' 是字符，"0" 是字符串。

类比不同生活场景中，大家对于不同容器的选择。

炒菜用到的容器是锅子；
喝茶用到的容器是杯子；
文具用到的容器是盒子；
上学用到的容器时车子；

但是，喝茶用到的杯子，也有大小之分，一杯星巴克，也有中杯、大杯、超大杯的区别。

程序中，存储相同数据类型的容器，也就是变量，也有大小之分。

变量的大小之分，是容量的不同，本质是变量所能存储数据的区间长度不同。以整数类型为例：

短整型 short ，小杯子，基本用不到
整型 int，大杯子，很常用，大小是 4 个字节长度，存储的数据区间：[-2³¹, 2³¹-1]，可最大表示 10 位数。
长整型 long long，超大杯，很常用，大小是 8 个字节长度，存储的数据区间是 [-2⁶³, 2⁶³-1]，可最大表示 19 位数。

基本数据类型划分：

整数类型，短整型 short、整型 int、长整型 long long。
浮点数类型，单精度浮点 float、双精度浮点 double。
字符类型，就是单个字符，仅此一种。
布尔类型，就两个值，true、false，也仅此一种。

任务2：基本数据类型很多，常用的就整型 int、长整型 long long、双精度浮点型 double、字符类型 char、布尔类型 bool

整数字面值 102、110、119 等，默认的数据类型是 int
浮点数字面值 1.00、3.14 等，默认的数据类型是 double
知识点有点多，实践中，慢慢就记住了，不需要背诵

点我，在线编程试一下👇

// 声明不同数据类型的变量，并输出
#include <iostream>
using namespace std;

int main() {

    // 字符串类型的姓名："" 括起来的信息，称之为字符串
    string name = "六一";
    // 整数类型的年龄
    int age = 12;
    // 字符类型的成绩
    char score = 'A';
    // 长整型的未来存款
    long long money = 9999999999999;
    // 浮点型的圆周率
    double pi = 3.14;
    // 布尔类型的 Are you ready?
    bool is_ready = true;
    
    cout << name << endl;
    cout << age << endl;
    cout << score << endl;
    cout << money << endl;
    cout << pi << endl;
    cout << is_ready << endl;

    return 0;
}

任务3：有感情的完成上述程序，并观察 is_ready 的输出结果。

你将看到，is_ready 的输出结果不是 true 而是数字 1。其实，C++ 中 true 其实是 1，false 其实是 0。 → 先记住就行。

整数类型

再来回顾一下，C++ 基本数据类型 - 整数类型。整数类型，细分为三种子类型：短整型 short、基本整型 int、长整型long long。

短整型 short，占用 2 个字节长度，可表示的数据区间有限，极少使用；
基本整型 int ，占用 4 个字节长度，对应数据区间是 [-2³¹, 2³¹ - 1]，也就是 [-2147483648, 2147483647]，经常使用。C++ 程序中，整数字面值的默认类型就是 int。

如果想要说明一个整数是 long long 类型的话，需要在数字后加上后缀 LL 或 ll。

另，当表示非负整数时，可使用无符号整型 unsigned int，简单理解成，无符号，就是无负号，即大于等于 0 的整数，对应数据区间是 [0, 2³²-1]，也就是 [0, 4294967295]。

长整型 long long，占用 8 个字节长度，在 int 不够用时，更换成 long long。

那么，int 何时不够用呢？
答案是：数据溢出时。int 类型可表示的最大数是 2147483647，如果两个整数，进行加法、乘法运算时，结果超过最大值 2147483647，则数据溢出，先记忆，直接调整成 long long。

注意：数据溢出，有时并不会报错，而是给出一个莫名其妙的结果。这个问题，暂不讨论。后续学习。

关于整数，先到这儿。

浮点数类型

浮点数类型，就是数学中的小数。细分为两个子类型，单精度浮点数 float、双精度浮点数 double。从名称上来说，double 显然精度更高，更常使用。C++ 程序中，浮点数字面值的默认类型是 double。

如果想要说明一个浮点数是 float 类型的话，需要在数字后加上后缀 F 或 f。

→ 关于后缀有很多好玩的事情和小应用，后面再来带大家实验。

实际编程中，一定是使用 double 类型的浮点数。

关于浮点数，也就是小数，有一个常见的数学问题需要解决，关于小数点后保留几位小数的问题。

且 C++ 使用 cout 输出 double 类型变量时，会有一些奇怪现象。经常出现小数位不能完全输出，或完全没有小数位，或输出了变量值的科学计数法表示。如何避免这类问题呢？

通用下面的程序解决，目前先解决小数位的问题。

点我，在线编程试一下👇

#include <iostream>
#include <iomanip>  // 导入浮点数小数位保留所需要的头文件 → 工具箱

using namespace std;

int main() {

    double pi = 335.1415926;
    cout << "PI is " << pi << endl;
    
    cout << fixed << setprecision(7);   // 该行代码之后，所有浮点数，都将保留 7 位小数
    cout << "PI is " << pi << endl;

    return 0;
}

任务4：有感情的完成上述程序，并尝试修改程序，保留不同小数位，观察并记录，是否存在四舍五入的现象。

#include <iomanip> 头文件导入
cout << fixed << setprecision(7); 保留具体数字

字符类型

字符类型 char，仅占用 1 个字节长度，对应数据区间是 [-2⁷, 2⁷ - 1]，也就是 [-128, 127] 之间。

常说到的字符编码 ASCII 中所有 128 个字符，均可直接使用 char 类型变量存储。

计算器底层存储任何数据，均使用的是二进制，也就是0、1组成的数字串，正常人，读不懂。所以便有了很多的字符编码，所谓字符编码，就是按照一定规则，将底层二进制串，翻译成对应的字符，便于使用和阅读。

ASCII 编码，就是其中一种编码方式。

计算机中存储字符 ‘A’ 使用的是一串二进制数，这串二进制数对应的十进制数是 65，以此类推，‘B’ 对应的 66，… ‘Z’ 对应的 90。小写字母对应的 ‘a’ ，其十进制数是 97，为对应大写字母十进制数加 32 得来。

字符 ‘0’ ，对应的是 48，‘1’ 对应的是 49，…，‘9’ 对应的是 57。

字符类型，经常使用，字符串底层就是一个多个字符组成的字符数组。字符数组是很多复杂问题的底层数据存储结构。记得很重要就可以了~

那么，字符对应的十进制数如何编程获得呢？
答案是：类型转换，将字符类型的变量转换成整数类型即可。→ 类型转换，是后文的重点，其实很简单。

点我，在线编程试一下👇

#include <iostream>
using namespace std;

int main() {

    // 通过类型转换验证，ASCII 编码下字符的十进制数值
    char ch_0 = '0';
    cout << "字符 '" << ch_0 << "' 对应的十进制数是：";
    cout << int(ch_0) << endl;  // 强制类型转换，使用 int(字符变量) 即可将字符变量的值转成整数

    char ch_9 = '9';
    cout << "字符 '" << ch_9 << "' 对应的十进制数是：";
    cout << int(ch_9) << endl;
    
    char ch_a = 'a';
    cout << "字符 '" << ch_a << "' 对应的十进制数是：";
    cout << int(ch_a) << endl;
    
    char ch_A = 'A';
    cout << "字符 '" << ch_A << "' 对应的十进制数是：";
    cout << int(ch_A) << endl;

    return 0;
}

任务5：有感情的完成上述程序，并尝试修改程序，尝试输出两个字符变量的差，cout << (ch_a - ch_A ) << endl; ，并记录答案。

PS：先混一个眼熟，后文来说明。
→ 直接将两个字符变量求差，得到的结果是，整数类型的数字。其中，程序将两个字符变量，分别隐式类型转换为整数类型后，再进行的求差。减法运算是数字的操作。

布尔类型

布尔类型，仅有两个值 true 真，false 假。很常用，很简单。

上文练习中，输出 true 时，屏幕输出的是 1。为啥呢》
就这么记，输出时，true 默认自动转为数字 1，false 默认自动转为数字 0。

通用理解，true 真，代表有，false 假，代表没有。所以，

整数 0、浮点是 0.0、空字符 ‘\0’、假 false，对应的布尔类型都是 false
整数 1、-1，浮点数 -0.1、12.34，任何非空字符等，对应的布尔类型都是true

下例，使用强制类型转换验证。
所谓，强制类型转换，就是将要转换的变量或者值放在括号里，想要转成什么类型，括号前就写上什么类型。（先这么认为）

点我，在线编程试一下👇

#include <iostream>
using namespace std;

int main() {

    // 通过类型转换验证，布尔类型
    char ch0 = '\0';
    char ch1 = '1';

    cout << "字符 '" << ch0 << "' 对应的布尔值是：";
    cout << bool(ch0) << endl; 
    cout << "字符 '" << ch1 << "' 对应的布尔值是：";
    cout << bool(ch1) << endl; 

    int n0 = 0;
    int n1 = 1;
    int n2 = -1;

    cout << "整数 '" << n0 << "' 对应的布尔值是：";
    cout << bool(n0) << endl; 
    cout << "整数 '" << n1 << "' 对应的布尔值是：";
    cout << bool(n1) << endl; 
    cout << "整数 '" << n2 << "' 对应的布尔值是：";
    cout << bool(n2) << endl; 

    double d0 = 0.0;
    double d1 = -0.1;
    double d2 = 12.34;

    cout << "浮点数 '" << d0 << "' 对应的布尔值是：";
    cout << bool(d0) << endl; 
    cout << "浮点数 '" << d1 << "' 对应的布尔值是：";
    cout << bool(d1) << endl; 
    cout << "浮点数 '" << d2 << "' 对应的布尔值是：";
    cout << bool(d2) << endl; 

    return 0;
}

数据类型转换

数据类型的转换，主要两种形式：

编译器，隐式 - 自动数据类型转换，通常是同种类型下，数据区间长度较小的子类型，运算时，自动转换成数据区间长度大的类型
编程时，根据需求手动进行的，显示 - 强制数据类型转换

隐式数据类型转换，是程序编译时，根据运算情况，自动进行的，无需手动进行。小类型转换成大类型。通常的转换路径是：

char 或 short → int → long long
char 或 short → int → float → double
注意：char 自动转换为 int，不会转换成 short

举例如下：

'A' + 0：隐式类型转换， ‘A’ 转换成整数 65，然后和 0 求和；
'0' + 0~9 数字：隐式类型转换，将个位整数转成对应的字符，0 转成 ‘0’；
'a' - 'A'：隐式类型转换，‘a’ 转换成整数 97，‘A’ 转换成整数 65，然后求差；
12 + 102.25：隐式类型转换，12 转换成双精度浮点数 12.0，然后求和；
整数 * 1.0：隐式类型转换，将整数转成浮点数，通常应用于，整数做除法，结果要小数时；

强制数据类型转换，根据需求，手动进行的转换，通常是，大类型转换成小类型。强制类型转换的格式为：目标数据类型(变量、表达式、数字)。

举例如下：

int(3.98)：强制类型转换，将双精度浮点数 3.98 转成对应整数 3，损失精度；
bool(100)：强制类型转换，将整数 100 ，转成对应布尔值 true；

重点回顾

回顾重点

基本数据类型：整型、浮点型、字符型、布尔型
基本数据类型的细分：
- 整型分为短整型 short、基本整型 int、长整型 long long，整数字面值，默认是基本整形 int
- 浮点型分为单精度浮点 float、双精度浮点 double，浮点数字面值，默认是双精度 double
- 字符型 char，可存储所有 ASCII 编码字符，字符 ‘A’ 对应整数 65，‘a’ 对应 97，以此类推，‘b’ 对应 98；字符 ‘0’ 对应时 48，‘1’ 对应是 49，以此类推
- 布尔型 bool，真 true 假 false ，输出时，true 对应 1，false 对应 0
数据类型转换：见上文
浮点数小数位保留问题，见上文