【语法2】输入语句与基础数据类型

moeyezi LV 6 MOD ~ 2025-8-13 15:28:14

输入语句与基础数据类型

`cin` 语句

cin >> a >> b >> c;

使用 >> 把要输入的内容依次传入进去。

int a, b;
char c;
cin >> a >> c >> b;
cout << a + b << "\n";
return 0;

输入这些分别会输出什么？

13+11 : 24
13-11 : 24
13 11 : 14

数据类型对应的范围

bit：位(1个二进制位)，计算机储存的最小单位
Byte：字节（8个连续的二进制位），计算机储存的基本单位
1 B(Byte) = 8 bit
1 KB(KiB) = 1024 B（ $2^{10}$ B）
1 MB(MiB) = 1024 KB
1 GB(GiB) = 1024 MB
1 TB(TiB) = 1024 GB
1 PB(PiB) = 1024 TB

数据类型名	内容(一般情况)	占用内存大小	能储存的范围	`scanf`/`printf` 标识符(g++)
`int`/`signed`	32 位整数	4 Bytes	$-2^{31}$ ~ $2^{31}$ - $1$ 约 $-2$ $\times$ $10^9$ ~ $2$ $\times$ $10^9$	`%d`/`%d`
`long long`	64 位整数	8 Bytes	$-2^{63}$ ~ $2^{63}$ - $1$ 约 $-9$ $\times$ $10^{18}$ ~ $9$ $\times$ $10^{18}$	`%lld`/`%lld`
`char`	字符	1 Byte	至少能储存 $0$ ~ $127$ 常见范围为 $-128$ ~ $127$	`%c`/`%c`
`float`	单精度浮点数	4 Bytes	$-3.4$ $\times$ $10^{38}$ ~ $3.4$ $\times$ $10^{38}$ 有效数字 $6$ ~ $7$ 位	`%f`/`%f`
`double`	双精度浮点数	8 Bytes	$-1.7$ $\times$ $10^{308}$ ~ $1.7$ $\times$ $10^{308}$ 有效数字 $15$ ~ $16$ 位	`%lf`/`%f`
`unsigned int`	无符号 32 位整数	4 Bytes	$0$ ~ $2^{32}$ - $1$ 约 $0$ ~ $4$ $\times$ $10^9$	`%u`/`%u`
`unsigned long long`	无符号 64 位整数	8 Bytes	$0$ ~ $2^{64}$ - $1$ 约 $0$ ~ $1.8$ $\times$ $10^{19}$	`%llu`/`%llu`

整数编码

基础二进制

二进制即要求满二进一，因此每一位为 0 或 1
二进制从最低位到最高位，数位的权值分别为：* $2^0$ , $2^1$ , $2^2$ , $2^3$ ,······
即 1,2,4,8,16,32,64,128,······
(101101)_2 转换成十进制结果如下

原始数位： 1  0 1 1 0 1
对应权值：32 16 8 4 2 1
转十进制：32 + 8 + 4 + 1 = 45

原码、反码、补码

原码
- 最高位为符号位，正数为 0，负数为 1。
- 剩下位置为原数绝对值的二进制。
反码
- 正数反码与原码一致。
- 负数反码除最高位之外，在原码基础上取反。
补码
- 正数补码与原码一致
- 负数补码在反码基础上加 1。

讨厌的浮点数

保留 x 位小数

方法 1

头文件：#include <cstdio>（<bits/stdc++.h> 包含了这个头文件）
语句： printf("%.xf", a);

方法 2（推荐）

头文件：#include<iostream>、#include<iomanip>（<bits/stdc++.h> 包含了这两个头文件）
语句：cout << fixed << setprecision(x) << a;

关于四舍五入

如果题目说保留 x 位小数，那么就按照上面方式输出就可以了。

但是需要注意的是，这种方式并不是我们直观中的四舍五入。

对于 4 舍和 6 入的部分是没有问题的，对于舍入位是 5，且后面还有大于 0 的数位时也是没有问题的。但如果舍入位是 5 且后没有其他数了，那么有可能会有两个小问题。

如果是 double 类型可以精确储存的数，那么会舍入到最接近的偶数数位，比如在保留 0 位小数的情况下：

0.5 -> 0
1.5 -> 2
2.5 -> 2
3.5 -> 4

保留 2 位小数的情况下：

1.125 -> 1.12
1.375 -> 1.38

如果是 double 类型无法无法精确储存的数，实际上储存的数可能会有一点点偏差，也会造成和我们所想不同。
比如如果输入 1.115，那么保留 2 位小数输出的会是 1.11，因为保留 20 位小数输出后，我们会发现实际储存的数大概是 1.11499999999999999112，执行的自然是 4 舍操作。

现在的出题人一般都不会说四舍五入，而是用精度控制，比如相对或绝对误差在 $10^{-6}$ （即 0.000001）以内就算对，此时你保留 7 位小数就肯定够了。

字符与整数的对应转换

char c;
int a;

数字字符与对应整数

'0' ~ '9' 对应的 ASCII 为 48 ~ 57
数字字符转换为对应整数：(int)(c - '0')
数字转换为对应字符：(char)(a + '0')

大小写字母映射到 0 ~ 25

'a' ~ 'z' 对应的 ASCII 为 97 ~ 122
'A' ~ 'Z' 对应的 ASCII 为 65 ~ 90
大写字母映射到 0 ~ 25：(int)(c - 'A')
小写字母映射到 0 ~ 25：(int)(c - 'a')

大小写字母之间转换

大写转小写：(char)(c - 'A' + 'a')
小写转大写：(char)(c - 'a' + 'A')

# 输入语句与基础数据类型

## `cin` 语句
**cin >> a >> b >> c;**

**使用 `>>` 把要输入的内容依次传入进去。**

```cpp
int a, b;
char c;
cin >> a >> c >> b;
cout << a + b << "\n";
return 0;
```
输入这些分别会输出什么？
- `13+11` :  *24*
- `13-11` :  *24*
- `13 11` :  *14*


## 数据类型对应的范围

- bit：位(1个二进制位)，计算机储存的最小单位
- Byte：字节（8个连续的二进制位），计算机储存的基本单位
- *1* B(Byte) = *8* bit
- *1* KB(KiB) = *1024* B（$2^{10}$ B）
- *1* MB(MiB) = *1024* KB
- *1* GB(GiB) = *1024* MB
- *1* TB(TiB) = *1024* GB
- *1* PB(PiB) = *1024* TB

| 数据类型名           | 内容(一般情况)   | 占用内存大小 | 能储存的范围                                                              | `scanf`/`printf` 标识符(g++) |
| -------------------- | ---------------- | ------------ | ------------------------------------------------------------------------- | ---------------------------- |
| `int`/`signed`       | 32 位整数        | 4 Bytes      | $-2^{31}$ ~ $2^{31}$-$1$ <br> 约 $-2$ $\times$ $10^9$ ~ $2$ $\times$ $10^9$           | `%d`/`%d`                    |
| `long long`          | 64 位整数        | 8 Bytes      | $-2^{63}$ ~ $2^{63}$-$1$ <br> 约 $-9$ $\times$ $10^{18}$ ~ $9$ $\times$ $10^{18}$    | `%lld`/`%lld`                |
| `char`               | 字符             | 1 Byte       | 至少能储存 $0$ ~ $127$ <br> 常见范围为 $-128$ ~ $127$                     | `%c`/`%c`                    |
| `float`              | 单精度浮点数     | 4 Bytes      | $-3.4$ $\times$ $10^{38}$ ~ $3.4$ $\times$ $10^{38}$ <br> 有效数字 $6$ ~ $7$ 位     | `%f`/`%f`                    |
| `double`             | 双精度浮点数     | 8 Bytes      | $-1.7$ $\times$ $10^{308}$ ~ $1.7$ $\times$ $10^{308}$ <br> 有效数字 $15$ ~ $16$ 位 | `%lf`/`%f`                   |
| `unsigned int`       | 无符号 32 位整数 | 4 Bytes      | $0$ ~ $2^{32}$-$1$ <br> 约 $0$ ~ $4$ $\times$ $10^9$                           | `%u`/`%u`                    |
| `unsigned long long` | 无符号 64 位整数 | 8 Bytes      | $0$ ~ $2^{64}$-$1$ <br> 约 $0$ ~ $1.8$ $\times$ $10^{19}$                      | `%llu`/`%llu`                |

## 整数编码

### 基础二进制

- 二进制即要求满二进一，因此每一位为 *0* 或 *1*
- 二进制从最低位到最高位，数位的权值分别为：*$2^0$, $2^1$ ,$2^2$ ,$2^3$ ,······
- 即 *1,2,4,8,16,32,64,128,······*
- *(101101)_2* 转换成十进制结果如下

```
原始数位： 1  0 1 1 0 1
对应权值：32 16 8 4 2 1
转十进制：32 + 8 + 4 + 1 = 45
```

### 原码、反码、补码

- 原码
  - 最高位为符号位，正数为 *0*，负数为 *1*。
  - 剩下位置为原数绝对值的二进制。
- 反码
  - 正数反码与原码一致。
  - 负数反码除最高位之外，在原码基础上取反。
- 补码
  - 正数补码与原码一致
  - 负数补码在反码基础上加 *1*。

## 讨厌的浮点数

### 保留 *x* 位小数

#### 方法 1

- 头文件：`#include <cstdio>`（`<bits/stdc++.h>` 包含了这个头文件）
- 语句： `printf("%.xf", a);`

#### 方法 2（推荐）

- 头文件：`#include<iostream>`、`#include<iomanip>`（`<bits/stdc++.h>` 包含了这两个头文件）
- 语句：`cout << fixed << setprecision(x) << a;`

### 关于四舍五入


如果题目说保留 *x* 位小数，那么就按照上面方式输出就可以了。  

但是需要注意的是，这种方式并不是我们直观中的四舍五入。

对于 *4* 舍和 *6* 入的部分是没有问题的，对于舍入位是 *5*，且后面还有大于 *0* 的数位时也是没有问题的。但如果舍入位是 *5* 且后没有其他数了，那么有可能会有两个小问题。  

**如果是 `double` 类型可以精确储存的数**，那么会舍入到最接近的偶数数位，比如在保留 *0* 位小数的情况下：  

- *0.5* -> *0*
- *1.5* -> *2*
- *2.5* -> *2*
- *3.5* -> *4*

保留 *2* 位小数的情况下：

- *1.125* -> *1.12*
- *1.375* -> *1.38*

**如果是 `double` 类型无法无法精确储存的数**，实际上储存的数可能会有一点点偏差，也会造成和我们所想不同。  
比如如果输入 *1.115*，那么保留 *2* 位小数输出的会是 *1.11*，因为保留 *20* 位小数输出后，我们会发现实际储存的数大概是 *1.11499999999999999112*，执行的自然是 *4* 舍操作。

现在的出题人一般都不会说四舍五入，而是用精度控制，比如相对或绝对误差在 *$10^{-6}$*（即 *0.000001*）以内就算对，此时你保留 *7* 位小数就肯定够了。

## 字符与整数的对应转换

```cpp
char c;
int a;
```

### 数字字符与对应整数

- `'0' ~ '9'` 对应的 ASCII 为 `48 ~ 57`
- 数字字符转换为对应整数：`(int)(c - '0')`
- 数字转换为对应字符：`(char)(a + '0')`

### 大小写字母映射到 *0 ~ 25*

- `'a' ~ 'z'` 对应的 ASCII 为 `97 ~ 122`
- `'A' ~ 'Z'` 对应的 ASCII 为 `65 ~ 90`
- 大写字母映射到 *0 ~ 25*：`(int)(c - 'A')`
- 小写字母映射到 *0 ~ 25*：`(int)(c - 'a')`

### 大小写字母之间转换

- 大写转小写：`(char)(c - 'A' + 'a')`
- 小写转大写：`(char)(c - 'a' + 'A')`

我们会审查剪贴板内容，并对发布不合适内容的同学进行相应的处理