2.1 数据类型介绍
C语言提供了丰富的数据类型来描述生活中的各种数据。使用整型类型来描述整数，使用字符类型来描述字符，使用浮点型类型来描述小数。所谓“类型”，就是相似的数据所拥有的共同特征，编译器只有知道了数据的类型，才知道怎么操作数据。
为什么要编程：解决生活中的问题，数据类型提供了描述生活中的应用场景的形式，例如商品名、定价等等…
内置类型：C语言本身就具有的类型； 自定义类型：自己来创建的类型，例如书籍的类型、自行车的类型等等…
一共有三种类型：浮点型（小数点可以移动）、整型、字符
char //字符数据类型 1
short //短整型 2
int //整形 4
long //长整型 4
long long //更长的整形 8
float //单精度浮点数 4
double //双精度浮点数 8
#include <stdio.h>
int main()
{
printf("%d\n", sizeof(char)); //1
printf("%d\n", sizeof(short)); //2
printf("%d\n", sizeof(int)); //4
printf("%d\n", sizeof(long)); //4
printf("%d\n", sizeof(long long)); //8
printf("%d\n", sizeof(float)); //4
printf("%d\n", sizeof(double)); //8
printf("%d\n", sizeof(long double)); //8
return 0;
}
// C语言规定：sizeof(long)>=sizeof(int)
// sizeof 类型（字节）可以用zu打印，即"%zu\n"
// 还有自定义类型 例如结构体 struct
sizeof的返回类型是sizet ,sizet size = sizeof(long)
计算机最小的单位是比特位(bit，二进制（0或1）) - 字节(byte，8个比特位) - kb（1024递进） - mb - gb - tb - pb
比特位越大，能使用的空间就更大（例如2个字节只能表示 00 01 10 11 ，相对应的是0 1 2 3）
int main()
{
int age = 20;
double price = 66.6;
printf("%f\n",3.5f);
printf("%c\n", 'q'); //printf打印字符
printf("%lf\n", 3.14); //printf打印双精度浮点型
return 0;
}
浮点数的四舍五入，不能用肉眼看到的数值来计算，因为浮点数在内存中，有可能不能精确保存。 例如看到了12.455，内存中可能存了12.4549888828282… ，就差一点点
2.1.1 字符
char
[signed] char //有符号的char
unsigned char //无符号的char
2.1.2 整型
//短整型
short [int] // int可以不写
[signed] short [int]
unsigned short [int]
//整型
int
[signed] int
unsigned int
//⻓整型
long [int]
[signed] long [int]
unsigned long [int]
//更⻓的整型
//C99中引入
long long [int]
[signed] long long [int]
unsigned long long [int]
2.1.3 浮点型
小数点是可以浮动的，例如3.14可以是0.31410，31.410^-1
float //单精度浮点型
double //双精度浮点型
long double //精度更高的浮点型
2.1.4 布尔类型
C语言原来并没有为布尔值单独设置一个类型，而是使用整数 0 表示假，非零值表示真。
在 C99 中也引入了 布尔类型 ，是专门表示真假的，即 _Bool。
布尔类型的使用得包含头文件 布尔类型变量的取值是：true或者false.
#define bool _Bool
#define false 0
#define true 1
#include <stdbool.h>
int main()
{
_Bool flag = true;
if (flag)
printf("i like C\n");
return 0;
}
2.1.5 字符串
"hello bit.\n"
这种由双引号（Double Quote）引起来的一串字符称为字符串字面值（String Literal），或者简称字符串。
注：字符串的结束标志是一个 \0 的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串内容。（占一个字符）
#include <stdio.h>
int main()
{
printf("%s\n", "hello C");
printf("hello c");
return 0;
}
例如"abcdef"肉眼看有6个字符，实际上有7个，还有一个\0，但是用strlen()，输出还是为6
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{
'a'; //字符常量（单引号）
char ch = 'w'; //字符变量，char是字符类型
"abcdef"; //常量字符串（双引号），C语言中没有字符串类型
char arr1[10] = "abcdefg"; //把字符串存储在arr中，字符串可以放10个字符,如果[]中不写数字，会自动确定空间,最后会默认存在转义符“\0”,不算做字符串内容，占一个字符，向内存申请空间为 a b c d e f g \0
char arr2[] = { 'a','b','c','d' ,'e' ,'f','g' }; //这样的写法，就没有“\0”，可以在ctrl+F10之后，点击调试 - 窗口 - 监视，输入arr2，便可以观察,向内存申请空间为a b c d e f g
printf("%s\n", arr1); //%s打印字符串
printf("%s\n", arr2); //会输出乱码 烫烫烫烫?...，即字符串需要结束标识，字符不需要，内存空间前后都有数据,因此字符串需要到\0才能停止
char arr3[] = { 'a','b','c','d' ,'e' ,'f','g','\0'}; //添加了\0，就可正常打印
printf("%s\n", arr3);
int len = strlen(arr1); //求字符串长度的一个函数 string length,头文件也是<string.h>
printf("%d\n", len);
printf("%d\n", strlen(arr2)); //arr2中字符串里没有\0，所以会继续往后找，是随机值
return 0;
}
//新增
char arr[4] = {'a','b','c'} //不完全初始化，剩余的部分默认为0，0和\0在ASCII中都是0，arr[8]也是一样，输出结果为3
printf("%d\n",strlen(arr)) -> 3
2.2 signed 和 unsigned
C语言使用 signed 和 unsigned 关键字修饰字符型和整型类型的。
signed 关键字，表示一个类型带有正负号，包含负值； 例如温度（有正有负） 对于 int 类型，默认是带有正负号的，也就是说 int 等同于 signed int 。
unsigned 关键字，表示该类型不带有正负号，只能表示零和正整数。 例如年龄（绝对正数） int 类型也可以不带正负号，只表示非负整数。这时就必须使用关键字 unsigned 声明变量。
整数变量声明为 unsigned 的好处是，同样⻓度的内存能够表示的最大整数值，增大了一倍。
比如，16位的 signed short int 的取值范围是：-32768~32767，最大是32767；而unsigned short int 的取值范围是：0~65535，最大值增大到了65,535。32位的 signed int 的取值范围可以参看 limits.h（可以在电脑里找到文件，打开看） 中给出的定义。
#define SHRT_MIN (-32768) //有符号16位整型的最小值
#define SHRT_MAX 32767 //有符号16位整型的最大值
#define USHRT_MAX 0xffff //无符号16位整型的最大值
#define INT_MIN (-2147483647 - 1) //有符号整型的最小值
#define INT_MAX 2147483647 //有符号整型的最大值
unsigned int 里面的 int 可以省略，所以上面的变量声明也可以写成 unsigned a; 。
字符类型 char 也可以设置 signed 和 unsigned 。 signed char c; // 范围为 -128 到 127 unsigned char c; // 范围为 0 到 255
注意，C语言规定 char 类型默认是否带有正负号，由当前系统决定。 这就是说， char 不等同于 signed char ，它有可能是 signed char ，也有可能是unsigned char 。 这一点与 int 不同， int 就是等同于 signed int。
2.3 数据类型的取值范围
上述的数据类型很多，尤其数整型类型就有short、int、long、longlong四种，为什么呢？
其实每一种数据类型有自己的取值范围，也就是存储的数值的最大值和最小值的区间，有了丰富的类型，我们就可以在适当的场景下去选择适合的类型。如果要查看当前系统上不同数据类型的极限值：
limits.h 文件中说明了整型类型的取值范围。 float.h 这个头文件中说明浮点型类型的取值范围。
为了代码的可移植性，需要知道某种整数类型的极限值时，应该尽量使用这些常量。
• SCHAR_MIN ， SCHAR_MAX ：signed char 的最小值和最大值。
• SHRT_MIN ， SHRT_MAX ：short 的最小值和最大值。
• INT_MIN ， INT_MAX ：int的最小值和最大值。
• LONG_MIN ， LONG_MAX ：long 的最小值和最大值。
• LLONG_MIN ， LLONG_MAX ：long long 的最小值和最大值。
• UCHAR_MAX ：unsigned char 的最大值。
• USHRT_MAX ：unsigned short 的最大值。
• UINT_MAX ：unsigned int 的最大值。
• ULONG_MAX ：unsigned long 的最大值。
• ULLONG_MAX ：unsigned long long 的最大值。
size_t - 是专门为sizeof设置的一个类型，本质是unsigned int，在打印时格式应使用%zd。
C语言规定：sizeof(long)≥sizeof(int)
2.4 变量和常量
2.4.1 变量的创建
类型是用来创建变量的，C语言中把经常变化的值称为变量，不变的值称为常量。
int age = 150;
float weight = 45.5;
char ch = 'w';
变量在创建的时候就给一个初始值，就叫初始化。
int age = 18;
char ch = 'w';
double weight = 45.01; //一般编译器会默认为double类型，如果把double类型的数值赋值给float，程序会报错；
float weight = 45.01f; //可以在后面增加f解决，会识别为float；
unsigned int height = 100
2.4.2 变量的分类
-
全局变量：在大括号外部定义的变量就是全局变量，即在 { } 外部定义的； 全局变量的使用范围更广，整个工程中想使用，都是有办法使用的。
-
局部变量：在大括号内部定义的变量就是局部变量，即在 { } 内部定义的； 局部变量的使用范围比较局限，只能在自己所在的局部范围内使用。
#include <stdio.h>
int global = 2019;//全局变量
int main()
{
int local = 2018;//局部变量
//下面定义的global会不会有问题？如果局部和全局变量，名字相同，那么优先使用局部变量
int global = 2020;//局部变量
printf("global = %d\n", global);
return 0;
}
在同一个范围内，变量只能初始化一次 ，局部变量中，变量名不能相同；全局和局部变量，变量名可以相同，但是局部变量优先。（建议不要将全局和局部变量的名字写成一样的）
全局变量和局部变量在内存中存储在哪里呢？
一般我们在学习C/C++语言的时候，我们会关注内存中的三个区域：栈区、堆区、静态区。
- 局部变量是放在内存的栈区
- 全局变量是放在内存的静态区
- 堆区是用来动态内存管理的三种用法：
1. 修饰局部变量-称为静态局部变量（static修饰的局部变量出了作用域，不销毁）
本质上，static修饰局部变量的时候，改变了变量的存储位置 - 由栈区改变到静态区，影响了变量的生命周期，和程序的生命周期一样。
栈区（存放局部变量...特点：进入作用域创建，出作用域销毁）；
堆区（动态内存管理 malloc/free/calloc/realloc）；
静态区（静态变量、全局变量...特点：出作用域不销毁，只有程序结束才销毁）
2. 修饰全局变量-称为静态全局变量
static修饰全局变量时，全局变量的外部链接属性就变成了内部链接属性，其他源文件(.c)（即外部）就不能再使用到这个全局变量，在内部（当前文件）还可以正常使用。
如果使用static修饰全局变量时，它的作用域就成整个工程（原先可以使用extern引用）变成了源文件内，在使用时感觉作用域边小了，本质上是外部链接属性转为内部链接属性。 - 一个变量的作用域太大不是好事，容易冲突，容易改变，不安全。
3. 修饰函数-称为静态函数
函数本身具有外部链接属性，但是被static修饰后，外部链接属性就变成了内部链接属性，和修饰全局变量一样的道理。
2.4.3 变量的使用
变量在创建的时候，需要给一个值，不给值也可以，但是会是随机的。
#include <stdio.h>
int main()
{
int num1 = 0; // 初始化变量，不初始化，运行会警报，且变量是随机值。
int num2 = 0;
int sum = 0;
printf("输入两个操作数:>");
scanf("%d %d", &num1, &num2);
sum = num1 + num2;
printf("sum = %d\n", sum);
return 0;
}
//这里介绍一下输入，输出语句
//scanf（&是给个地址，即输入值后，会进入到&后面的变量中）
//printf
2.4.4 变量的作用域和生命周期
作用域（scope）
作用域（scope）是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用 的，而限定这个名字的可用性的代码范围就是这个名字的作用域。（这段代码在哪里可以使用，哪里就是它的作用域）
- 局部变量的作用域是变量所在的局部范围。（括号内部的任意范围，包括括号内部的括号）
- 全局变量的作用域是整个工程。
int a = 10;
extern int a; //需要先声明变量（声明来自外部的符号）
变量的生命周期
变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段。和作用域类似，但是维度不同。
- 局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。
- 全局变量的生命周期是：整个程序的生命周期。
2.4.5 常量
C语言中的常量和变量的定义的形式有所差异。
常量即为描述那些不变的量。
C语言中的常量分为以下以下几种：
- 字面常量（单独一个 30; 或者3.14；或者'w' //字符；"abc" //字符串）
int main()
{
30;
3.14;
'a'; //字符
"abc"; //字符串
return 0;
}
- const 修饰的常变量（修改const对象，编译器会报错）
int main()
{
const int a = 10; //在C语言中，const修饰的a，本质是变量，但是不能直接修改，有常量的属性
printf("%d", a);
return 0;
}
int main()
{
int n = 10; //如果在这前面加上const，也不能运行，因为此时const修饰的n仍然不是常量
int arr[n] = {0}; //会报错，需要数组里面的值为常量，此时的n是变量
int arr[10] = {0}; //正确写法，数组中放常量
return 0;
}
- #define 定义的标识符常量
#define MAX 100
#define STR "abcdef"
int main()
{
printf("%d\n", MAX);
int a = MAX;
printf("%d\n", a);
printf("%s\n", STR);
MAX = 200; //会报错
return 0;
}
>>100
100
abcdef
MAX是标识符常量（可以理解为全局常变量，但是没有类型）
- 枚举常量
枚举常量不能被修改，否则会报错，如下方的RED和MALE
enum Color //下面的是这个类型变量的可能取值
{
//枚举常量
RED,
GREEN,
BLUE
};
//性别
enum Sex //下面的是这个类型变量的可能取值
{
MALE,
FEMALE,
SECRET
};
int main()
{
//三原色
//Red Green Blue
int num = 10;
enum Color c = RED; //创建了变量c是向内存申请了空间，而常量符号不会申请空间
RED = 100; //ERR
MALE = 20; //ERR
return 0;
}
一般情况下，标识符常量，枚举常量，最好是写成大写（习惯）
2.5 算术操作符：+、-、*、/、%
在写代码时候，一定会涉及到计算。
C语言中为了方便运算，提供了一系列操作符，其中有一组操作符叫：算术操作符。分别是： + - * \ % ，都是双目操作符（一个操作符，有两个操作数，所以叫做双目操作符，sizeof只有一个操作数，所以叫单目操作符）。
注：操作符也被叫做：运算符，是不同的翻译，意思是一样的。
//算术操作符
+ - *
/ 除号得到的是商，除号两端都是整数的时候，执行的是整数除法，如果两端只要有一个浮点数，执行的是浮点数的除法
% 取模得到的是余数，取模操作符的两端只能是整数，不能是其他数字
//移位操作符
>> 左移操作符
<< 右移操作符
//位操作符
&
^
|
//赋值操作符
= 赋值
+= 同python 即a = a+x -- a += x
-= 同下
*=
/=
&= ^= |= >>= <<=
//单目操作符 - 只有一个操作数的操作符
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置、后置--，后置++为先使用后再++，即+1
++ 前置、后置++
* 间接访问操作符(解引用操作符)
(类型) 强制类型转换
int main()
{
int flag = 0; //flag为假
if (!flag) //使用逻辑反操作，此时的 !flag 为真，执行下方语句
{
printf("hehe\n");
}
int a =10;
int b = a++;
printf("%d\n",b); //10,使用后再++
printf("%d\n",a); //11
int a =10;
int b = ++a;
printf("%d\n",b); //11
printf("%d\n",a); //11
int a = 3.14; //3.14字面浮点数，编译器默认为double类型
int a = (int)3.14; //输出结果为3，强制转换
return 0;
}
//关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”（如果用 = 做比较，那么就会进入0为假，非0为真的逻辑
//逻辑操作符
&& 逻辑与 - 并且
|| 逻辑 - 或者
int main()
{
int a = 10;
int b = 20;
if(a && b)
{
printf("两者都为真，则为真\n");
}
if(a || b)
{
printf("其中一个为真，则为真\n");
}
return 0;
}
//条件操作符（三目操作符，有三个操作数）
exp1 ? exp2 : exp3 //表达式1 表达式2 表达式3
//表达式1如果为真，表达式2算，表达式3不算
//表达式1如果为假，表达式2不算，表达式3算
int main()
{
int a = 30;
int b = 20;
int r = a > b ? a : b; //int r = (a > b ? a : b);
printf("%d\n", r);
return 0;
}
//逗号表达式,就是逗号隔开的一串表达式；
//逗号表达式的特点是：从左向右依次计算，整个表达式的结果是最后一个表达式的结果
exp1, exp2, exp3, ...expN
int main()
{
int a = 10;
int b = 20;
int c = 0;
int d = (c=a-2,a=b+c,c-3) // c=10-2=8 a=20+8=28 c=8-3=5 ,d是最后一个表达式的结果，为5
printf("%d\n", d); //5
return 0;
}
//下标引用、函数调用和结构成员
[] 下标引用操作符，例如arr[0],arr和3就是[]的操作数；n=3;arr[3]=20 可以这么写，下标可以使用变量
() 函数调用操作符，例如int sum = Add(2,3)，Add，2，3都是()的操作数
. 结构体对象.成员名 例如 s.name
-> 结构体指针变量->成员名 例如 (*ps).name 可以写作 ps->name
需要注意：
① / 除号两端都是整数的时候，执行的是整数除法；如果两端只要有一个浮点数，执行的是浮点数的除法。（%.1f是小数点后面只有一位）；
#include <stdio.h>
int main()
{
int score = 5;
score = (score / 20) * 100;
return 0;
}
>>> 0
上面的代码，你可能觉得经过运算， score 会等于 25 ，但是实际上 score 等于 0 。这是因为 score / 20 是整除，会得到一个整数值 0 ，所以乘以 100 后得到的也是 0 。
为了得到预想的结果，可以将除数 20 改成 20.0 ，让整除变成浮点数除法。
#include <stdio.h>
int main()
{
int score = 5;
score = (score / 20.0) * 100;
return 0;
}
② C语言中，0表示假，非0表示真；
③ sizeof是操作符，是单目操作符，不是函数
sizeof(a)可以，如果后面是名字/变量，则删除括号也可以，sizeof a ，sizeof(int)，如果后面是类型，则括号不能省略； ****int arr[10] = {0}; printf("%d\n",sizeof(arr)); //结果是40，计算的是整个数组的大小，单位是字节 printf("%d\n",sizeof(arr[0])); //结果是4 printf("%d\n",sizeof(arr) / sizeof(arr[0])); //结果是10 - 数组的元素个数
④ n=3;arr[n]="20"(修改数组内元素); 可以这么写，下标可以使用变量，但是数组创建时，不能用变量作为[]内元素；
⑤ % 取模两端只能是整数，负数求模的规则是，结果的正负号由第一个运算符决定。
#include <stdio.h>
int main()
{
printf("%d\n", 11 % -5); // 1
printf("%d\n",-11 % -5); // -1
printf("%d\n",-11 % 5); // -1
return 0;
}
⑥ = 赋值操作符可以连续赋值，从右向左依次赋值。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int a = 3;
int b = 5;
int c = 0;
c = b = a + 3;
printf("a=%d b=%d c=%d", a, b, c);
return 0;
}
>>> a=3 b=6 c=6
//计算顺序如下：
b = a+3;
c = b;
C语言虽然支持这种连续赋值，但是写出的代码不容易理解，建议还是拆开来写，这样方便观察代码的执行细节。
⑦ 强行转换（不提倡）
int a = 3.14;//a的是int类型, 3.14是double类型，两边的类型不一致，编译器会报警告
int a = (int)3.14;//意思是将3.14强制类型转换为int类型，这种强制类型转换只取整数部分1
俗话说，强扭的瓜不甜，我们使用强制类型转换都是万不得已的时候使用，如果不需要强制类型转化就能实现代码，这样自然更好的。
强制类型转换就是为了解决两边类型不一样的问题，int a =(int)3.14; 输出结果为3；
单目操作符：++、--、+、-
前面介绍的操作符都是双目操作符，有2个操作数的。C语言中还有一些操作符只有一个操作数，被称为单目操作符。 ++、--、+(正)、-(负) 就是单目操作符的。
++和--
++是一种自增的操作符，又分为前置++和后置++，--是一种自减的操作符，也分为前置--和后置--；
-
前置++
```C int a = 10; int b = ++a; //++的操作数是a，是放在a的前面的，就是前置++ printf("a=%d b=%d\n",a,b);
**计算口诀：先+1，后使用；**
a原来是10，先+1，后a变成了11，再使用就是赋值给b，b得到的也是11，所以计算技术后，a和b都
是11，相当于如下代码：
```C
int a = 10;
a = a+1;
b = a;
printf("a=%d b=%d\n",a , b)
-
后置++
```C int a = 10; int b = a++; //++的操作数是a，是放在a的后面的，就是后置++ printf("a=%d b=%d\n",a , b);
**计算口诀：先使用，后+1**
a原来是10，先使用，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，所以直接结束后a是
11，b是10，相当于这样的代码：
```C
int a = 10;
int b = a;
a = a+1;
printf("a=%d b=%d\n",a , b);
-
前置--
```C int a = 10; int b = --a; //--的操作数是a，是放在a的前面的，就是前置-- printf("a=%d b=%d\n",a , b); //输出的结果是：9 9
**计算口诀：先-1，后使用**
a原来是10，先使用，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，所以直接结束后a是
11，b是10，相当于这样的代码：
- 后置--
```C
int a = 10;
int b = a--;//--的操作数是a，是放在a的后面的，就是后置--
printf("a=%d b=%d\n",a , b);//输出的结果是：9 10
**计算口诀：先使用，后-1**
2.6 scanf和printf介绍
2.6.1 printf 基本用法
printf() 是在标准库的头文件 定义的。使用这个函数之前，必须在源码文件头部引入这个头文件。
printf() 的作用是将参数文本输出到屏幕。它名字里面的 f 代表 format（格式化），表示可以定制输出文本的格式。
printf() 不会在行尾自动添加换行符，运行结束后，光标就停留在输出结束的地方，不会自动换行。 为了让光标移到下一行的开头，可以在输出文本的结尾，添加一个换行符 \n 。
2.6.2 printf 转义字符
转义字符 - 转变了原有意思的字符。
• \? ：在书写连续多个问号时使用，防止他们被解析成三字母词，在新的编译器上没法验证了。
• \' ：用于表示字符常量'
• \" ：用于表示一个字符串内部的双引号
• \\ ：用于表示一个反斜杠，防止它被解释为一个转义序列符。
• \a ：警报，这会使得终端发出警报声或出现闪烁，或者两者同时发生。
• \b ：退格键，光标回退一个字符，会删除字符。
• \f ：换⻚符，光标移到下一⻚。在现代系统上，这已经反映不出来了，行为改成类似于 \v 。
• \n ：换行符。
• \r ：回车符，光标移到同一行的开头。
• \t ：制表符，光标移到下一个水平制表位，通常是下一个8的倍数。
• \v ：垂直分隔符，光标移到下一个垂直制表位，通常是下一行的同一列。
下面2种转义字符可以理解为：字符的8进制或者16进制表示形式
• \ddd ：ddd表示1~3个八进制的数字。 如：\130表示字符X
• \xdd ：dd表示2个十六进制数字。如： \x30表示字符0
• \0 ：null 字符，代表没有内容， \0 就是 \ddd 这类转义字符的一种，用于字符串的结束标志，其ASCII码值是0
注意，早期有些编译器，会存在三字母词：
??) --- ]
??( --- [
如果不想问号和括号被转义，可以在问号前面加上\ ，避免被转义成三字母词 ，\?
2.6.3 printf 占位符
printf() 可以在输出文本中指定占位符，所谓“占位符”，就是这个位置可以用其他值代入。
#include <stdio.h>
int main()
{
printf("There are %d apples\n", 3);
return 0;
}
>>> There are 3 apples
常用的占位符除了 %d ，还有 %s 表示代入的是字符串。
printf() 参数与占位符是一一对应关系，如果有 n 个占位符， printf() 的参数就应该有 n+1 个。如果参数个数少于对应的占位符， printf() 可能会输出内存中的任意值。
printf() 的占位符有许多种类，与C语言的数据类型相对应。
• %a ：十六进制浮点数，字母输出为小写。
• %A ：十六进制浮点数，字母输出为大写。
• %c ：字符。
• %d ：十进制整数。
• %e ：使用科学计数法的浮点数，指数部分的 e 为小写。
• %E ：使用科学计数法的浮点数，指数部分的 E 为大写。
• %i ：整数，基本等同于 %d 。
• %f ：小数（包含 float 类型和 double 类型）。
• %g ：6个有效数字的浮点数。整数部分一旦超过6位，就会自动转为科学计数法，指数部分的 e
为小写。
• %G ：等同于 %g ，唯一的区别是指数部分的 E 为大写。
• %hd ：十进制 short int 类型。
• %ho ：八进制 short int 类型。
• %hx ：十六进制 short int 类型。
• %hu ：unsigned short int 类型。
• %ld ：十进制 long int 类型。
• %lo ：八进制 long int 类型。
• %lx ：十六进制 long int 类型。
• %lu ：unsigned long int 类型。
• %lld ：十进制 long long int 类型。
• %llo ：八进制 long long int 类型。
• %llx ：十六进制 long long int 类型。
• %llu ：unsigned long long int 类型。
• %Le ：科学计数法表示的 long double 类型浮点数。
• %Lf ：long double 类型浮点数。
• %n ：已输出的字符串数量。该占位符本身不输出，只将值存储在指定变量之中。
• %o ：八进制整数。
• %p ：指针。
• %s ：字符串。
• %u ：无符号整数（unsigned int）。
• %x ：十六进制整数。
• %zd ： size_t 类型。
• %% ：输出一个百分号。
printf() 可以定制占位符的输出格式。
-
限定宽度（是至少的意思，不是超过限定就删除！）
printf() 允许限定占位符的最小宽度（% [] d ，正数为在前端加空格凑齐，负数为在后端增加空格）。
#include <stdio.h>
int main()
{
printf("%5d\n", 123); // 输出为 " 123",至少打印5位，不够5位会拿空格来填充，右对齐
return 0;
}
#include <stdio.h>
int main()
{
printf("%-5d\n", 123); // 输出为 "123 "，左对齐
return 0;
}
对于小数，这个限定符会限制所有数字的最小显示宽度。
#include <stdio.h>
int main()
{
printf("%12f\n", 123.45); // 输出 " 123.450000" 小数点也算上
return 0;
}
%12f 表示输出的浮点数最少要占据12位。由于小数的默认显示精度是小数点后6位，所以 123.45 输出结果的头部会添加2个空格。
-
总是显示正负号
默认情况下， printf() 不对正数显示 + 号，只对负数显示 - 号。如果想让正数也输出 + 号，可以在占位符的 % 后面加一个 + 。
#include <stdio.h>
int main()
{
printf("%+d\n", 12); // 输出 +12
printf("%+d\n", -12); // 输出 -12
return 0;
}
-
限定小数位数
输出小数时，有时希望限定小数的位数。举例来说，希望小数点后面只保留两位，占位符可以写成 %.2f 。
#include <stdio.h>
int main()
{
printf("Number is %.2f\n", 0.5); // 输出 Number is 0.50
return 0;
}
这种写法可以和限定宽度同时使用。
#include <stdio.h>
int main()
{
printf("%6.2f\n", 0.5); // 输出为 " 0.50"
return 0;
}
最小宽度和小数位数这两个限定值，都可以用 * 代替，通过 printf() 的参数传入。 下面示例中， %*.*f 的两个星号通过 printf() 的两个参数 6 和 2 传入.
#include <stdio.h>
int main()
{
printf("%*.*f\n", 6, 2, 0.5); // 等同于printf("%6.2f\n", 0.5);
return 0;
}
-
输出部分字符串
%s 占位符用来输出字符串，默认是全部输出。如果只想输出开头的部分，可以用 %.[m]s 指定输出的⻓度，其中 [m] 代表一个数字，表示所要输出的⻓度。
#include <stdio.h>
int main()
{
//占位符 %.5s 表示只输出字符串“hello world”的前5个字符，即“hello”
printf("%.5s\n", "hello world");
return 0;
}
2.6.4 scanf 基本用法
当我们有了变量，我们需要给变量输入值就可以使用 scanf 函数，如果需要将变量的值输出在屏幕上的时候可以使用 printf 函数;
#include <stdio.h>
int main()
{
int score = 0;
printf("请输入成绩:");
scanf("%d", &score);
printf("成绩是：%d\n", score);
return 0;
}
scanf() 函数用于读取用户的键盘输入。
程序运行到这个语句时，会停下来，等待用户从键盘输入。
用户输入数据、按下回车键后， scanf() 就会处理用户的输入，将其存入变量。
它的原型定义在头文件 stdio.h ，语法为 scanf("%d", &i);
注意，数组不需要在前面加上 &
-
⭐ scanf_s报错指南
scanf( ) 是输入函数，类似于python的 input( ) 函数
在运行时会有错误，即：
-
报错含义：此函数或变量可能不安全。请考虑改用scanfs。要禁用弃用，请使用CRTSECURENO_WARNINGS。
更改方案：复制后面的 “CRTSECURENOWARNINGS”，在程序的第一行（一定要是第一行！）写上 #define CRTSECURENOWARNINGS
scanfs 这个函数是VS编译器自己提供的函数，非标准C提供的函数，只有VS编译器认识，其他编译器不认识，所以如果想跨平台使用，建议使用scanf，如果一定要使用scanfs，请研究一下再使用。
一劳永逸的方法：在VS的安装路径下有一个文件：newc++file.cpp的文件，在VS工程中创建新的.c或者.cpp文件的时候，都是拷贝这个文件的！可以利用everything，查找到这个文件路径，用记事本打开，修改添加第一行代码为 #define CRTSECURENOWARNINGS ，即可一劳永逸。（无权限的情况下，可以复制，张贴到桌面，修改好后，替换掉原文件夹中的文件。如果是移动，没有移回源文件夹，会导致在新建源文件的时候，缺少c++的选项）
或者在源文件上方写上 #pragma warning(disable:4996) 即要处理的警告
它的第一个参数是一个格式字符串，里面会放置占位符（与 printf() 的占位符基本一致），告诉编译器如何解读用戶的输入，需要提取的数据是什么类型。
这是因为C语言的数据都是有类型的， scanf() 必须提前知道用戶输入的数据类型，才能处理数据。
它的其余参数就是存放用戶输入的变量，格式字符串里面有多少个占位符，就有多少个变量。
上面示例中， scanf() 的第一个参数 %d ，表示用戶输入的应该是一个整数。 %d 就是一个占位符， % 是占位符的标志， d 表示整数。第二个参数 &i 表示，将用戶从键盘输入的整数存入变量i 。
注意：变量前面必须加上 & 运算符（指针变量除外），因为 scanf() 传递的不是值，而是地址，即将变量 i 的地址指向用戶输入的值。 如果这里的变量是指针变量（比如字符串变量），那就不用加 & 运算符
键盘输入多个变量：scanf("%d%d%f%f", &i, &j, &x, &y) 格式字符串 %d%d%f%f ，表示用戶输入的前两个是整数，后两个是浮点数，比如 1 -20 3.4 -4.0e3 。这四个值依次放入 i 、 j 、 x 、 y 四个变量。
scanf() 处理数值占位符时，会自动过滤空白字符，包括空格、制表符、换行符等，所以，用戶输入的数据之间，有一个或多个空格不影响 scanf() 解读数据。另外，用戶使用回⻋键，将输入分成几行，也不影响解读（即有n个变量，可以分为n行输入）。
scanf() 处理用戶输入的原理是，用戶的输入先放入缓存，等到按下回⻋键后，按照占位符对缓存进行解读。
解读用戶输入时，会从上一次解读遗留的第一个字符开始，直到读完缓存，或者遇到第一个不符合条件的字符为止。
#include <stdio.h>
int main()
{
int x;
float y;
// 用戶输入 " -13.45e12# 0" , .45e12 表示0.45 * 10的12次方，属于科学计数法
scanf("%d", &x);
scanf("%f", &y);
printf("%d\n%f", x, y);
return 0;
}
上面示例中， scanf() 读取用戶输入时， %d 占位符会忽略起首的空格，从 - 处开始获取数据，读取到 -13 停下来，因为后面的 . 不属于整数的有效字符。这就是说，占位符 %d 会读到 -13 。
第二次调用 scanf() 时，就会从上一次停止解读的地方，继续往下读取。这一次读取的首字符是 . ，由于对应的占位符是 %f ，会读取到 .45e12 ，这是采用科学计数法的浮点数格式。后面的# 不属于浮点数的有效字符，所以会停在这里。
由于 scanf() 可以连续处理多个占位符，所以上面的例子也可以写成下面这样。
#include <stdio.h>
int main()
{
int x;
float y;
// 用戶输入 " -13.45e12# 0"，输出结果和上面一样
scanf("%d%f", &x, &y);
return 0;
}
scanf()的返回值
scanf() 的返回值是一个整数，表示成功读取的变量个数。（可以用整型 int 接收）
如果没有读取任何项，或者匹配失败，则返回 0 。如果在成功读取任何数据之前，发生了读取错误或者遇到读取到文件结尾，则返回常量EOF - end of file 文件的结束标志，即为 -1 。
#include <stdio.h>
int main()
{
int a = 0;
int b = 0;
float f = 0.0f;
int r = scanf("%d %d %f", &a, &b, &f); //用整形变量接收scanf的返回值
printf("a=%d b=%d f=%f\n", a, b, f);
printf("r = %d\n", r);
return 0;
}
输入输出测试：
如果输入2个数后，按 ctrl+z ，提前结束输入：
在VS环境中按3次 ctrl+z ，才结束了输入，我们可以看到r是2，表示正确读取了2个数值。如果一个数字都不输入，直接按3次 ctrl+z ,输出的r是-1，也就是EOF
2.6.5 scanf 的占位符
scanf() 常用的占位符如下，与 printf() 的占位符基本一致。
• %c ：字符。 • %d ：整数。 • %f ： float 类型浮点数。 • %lf ： double 类型浮点数。 • %Lf ： long double 类型浮点数。 • %s ：字符串。 • %[] ：在方括号中指定一组匹配的字符（比如 %[0-9] ），遇到不在集合之中的字符，匹配将会停止。
🔺 上面所有占位符之中，除了 %c 以外，都会自动忽略起首的空白字符。 %c 不忽略空白字符，总是返回当前第一个字符，无论该字符是否为空格。（只取第一个字符）
如果要强制跳过字符前的空白字符，可以写成 scanf(" %c", &ch) ，即 %c 前加上一个空格，表示跳过零个或多个空白字符。
下面要特别说一下占位符 %s ，它其实不能简单地等同于字符串。它的规则是，从当前第一个非空白字符开始读起，直到遇到空白字符（即空格、换行符、制表符等）为止。
因为 %s 不会包含空白字符，所以无法用来读取多个单词，除非多个 %s 一起使用。这也意味着，scanf() 不适合读取可能包含空格的字符串，比如书名或歌曲名。另外， scanf() 遇到 %s 占位符，会在字符串变量末尾存储一个空字符\0.
scanf() 将字符串读入字符数组时，不会检测字符串是否超过了数组⻓度。所以，储存字符串时，很可能会超过数组的边界，导致预想不到的结果。为了防止这种情况，使用 %s 占位符时，应该指定读入字符串的最⻓⻓度，即写成 %[m]s ，其中的 [m] 是一个整数，表示读取字符串的最大⻓度，后面的字符将被丢弃。
#include <stdio.h>
int main()
{
char name[11];
scanf("%10s", name);
return 0;
}
上面示例中， name 是一个⻓度为11的字符数组， scanf() 的占位符 %10s 表示最多读取用戶输入的10个字符，后面的字符将被丢弃，这样就不会有数组溢出的⻛险了。
2.6.6 赋值忽略符
#include <stdio.h>
int main()
{
int year = 0;
int month = 0;
int day = 0;
scanf("%d-%d-%d", &year, &month, &day);
return 0;
}
上面示例中，如果用戶输入 2020-01-01 ，就会正确解读出年、月、日。问题是用戶可能输入其他格式，比如 2020/01/01，这种情况，scanf()解析数据就会失败。
为了避免这种情况，scanf()提供了赋值忽略符（assignment suppression character） * ，只要把 * 加在任意占位符的百分号后面，该占位符就不会返回值，解析后被丢弃。
#include <stdio.h>
int main()
{
int year = 0;
int month = 0;
int day = 0;
scanf("%d%*c%d%*c%d", &year, &month, &day);
return 0;
}
上面示例中， %*c 就是在占位符的百分号后面，加入了赋值忽略符 * ，表示这个占位符没有对应的变量，解读后不必返回。
749
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
