文章目录
数据类型介绍
C语言提供了丰富的数据类型来描述生活中的各种数据。
使用整型类型来描述整数,使用字符类型来描述字符,使用浮点型类型来描述小数。
所谓“类型”,就是相似的数据所拥有的共同特征,编译器只有知道了数据的类型,才知道怎么操作数据。
下面盘点一下C语言提供的各种数据类型,本章节主要探讨内置数据类型。
字符型
注:以下[]
均表示可以省略。
char //character字符
[signed] char //有符号的字符类型
unsigned char //无符号的字符类型
整型
//短整型
short [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]
浮点型
float //单精度浮点数
double //双精度浮点数
long double
布尔类型
C 语言原来并没有为布尔值单独设置一个类型,而是使用整数 0 表示假,非零值表示真。
在 C99 中也引入了 布尔类型 ,是专门表示真假的。
_Bool
布尔类型的用得包含头文件 <stdbool.h>
布尔类型变量的取值是:true
或者 false
#define bool _Bool
#define false 0 //在C语言中0表示假,非0表示真
#define true 1
代码演示
#include<stdio.h>
int main()
{
_Bool flag = ture;
if(flag) //如果flag为真,打印下面一句话
printf("i like C \n");
return 0;
}
各种数据类型的长度
每一种数据类型都有自己的长度,使用不同的数据类型,能够创建出长度不同的变量,变量长度的不同,存储的数据范围就有所差异。
sizeof操作符
sizeof
是一个关键字,也是操作符,专门是用来计算sizeof
的操作符数的类型长度的,单位是字节。
sizeof(变量)
sizeof(类型)
sizeof 表达式
sizeof
操作符的操作数可以是类型,也可是变量或者表达式。
sizeof
的操作数如果不是类型,是表达式的时候,可以省略掉后边的括号的。
sizeof
后边的表达式是不真实参与运算的,根据表达式的类型来得出大小。
sizeof
的计算结果是 size_t
类型的。
但是需要注意这里的表达式,要赋给一个变量,再放这里才能省略括号噢!下面就是小编曾经遇到的问题,我们来分析一下这个9是怎么来的。
首先,sizeof
只计算类型的长度,int
整型的长度是4个字节,在没有加()
的情况下,sizeof a
计算的结果是a
这个整型变量的长度,为4,所以返回值是4,4+5=9,所以打印结果为9,而不是4。操作数是表达式的请参照上图的最后两行代码。
sizeof
运算符的返回值,C 语言只规定是无符号整数,并没有规定具体的类型,而是留给
系统自己去决定, sizeof
到底返回什么类型。不同的系统中,返回值的类型有可能是
unsigned int
,也有可能是 unsigned long
,甚至是 unsigned long long
,
对应的 printf()
占位符分别是 %u
、 %lu
和 %llu
。这样不利于程序的可移植性。
C 语言提供了一个解决方法,创造了一个类型别名size_t
,用来统一表示sizeof
的返回值类型。对应当前系统的 sizeof
的返回值类型,可能是 unsigned int
,也可能是
unsigned long long
数据类型长度
这里简单说一下数据在计算机中的存储单位:
bit-比特位
Byte-字节
KB
MB
GB
TB
PB
…
换算关系:
1 Byte = 8 bit
1 MB = 1024 KB
1 GB = 1024MB
1 TB =1024 GB
1 PB =1024 TB
…
计算各数据类型长度的代码如下:
int main()
{
printf("%zd\n", sizeof(char));
printf("%zd\n", sizeof(short));
printf("%zd\n", sizeof(int));
printf("%zd\n", sizeof(long));
printf("%zd\n", sizeof(long long));
printf("%zd\n", sizeof(float));
printf("%zd\n", sizeof(double));
printf("%zd\n", sizeof(long double));
return 0;
}
在VS2019配置下的输出结果如图:
我们可以发现,整型int
和长整型long
都是四个字节,这是因为sizeof(long)>=sizeof(int)
,long
可以是4个字节,也可以是8个字节。
sizeof中表达式不计算
int main()
{
int a = 10;
short s = 4;
printf("%zd\n", sizeof(s = a + 5));
printf("s = %d\n", s);
return 0;
}
输出结果如下:
a
是整型,占4个字节,5是整型,也占4个字节,加起来依然是整型,依然占4个字节,但是,s
是短整型,只有两个字节的空间,不够放,此时就发生截断,输出的是两个字节的长度,2。
sizeof
在代码进行编译的时候,就根据表达式的类型确定了,类型常用,而表达式的执行却要在程序运行期间才能执行,在编译期间已经将sizeof
处理掉了,所以在运行期间就不会执行表达式了。
signed和unsigned
- C 语言使用
signed
和unsigned
关键字修饰字符型和整型类型的。 signed
关键字,表示一个类型带有正负号,包含负值;unsigned
关键字,表示该类型不带有正负号,只能表示零和正整数。- 对于
int
类型,默认是带有正负号的,也就是说int
等同于signed int
。
由于这是默认情况,关键字signed
一般都省略不写,但是写了也不算错。
signed int a=0;
//等同于 int a=0;
int
类型也可以不带正负号,只表示非负整数。这时就必须使用关键字unsigned
声明变量。
unsigned int a=0;
整数变量声明为unsigned
的好处是,同样长度的内存能够表示的最大整数值,增大了一倍。
比如,16位的signed short int
的取值范围是:-32768~32767
,最大是32767
;
⽽unsigned short int
的取值范围是:0~65535
,最大值增大到了65535
。
32位的signed int
的取值范围可以参看limits.h
中给出的定义。
下面的定义是VS2019环境中,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 //有符号整型的最⼤值
字符类型 char
也可以设置 signed
和 unsigned
。
signed char c = 0;
unsigned char c = 0;
注意,C 语言规定 char
类型默认是否带有正负号,由当前系统决定。
这就是说, char
不等同于 signed char
,它有可能是 signed char
,也有可能是unsigned char
。
这一点与 int
不同, int
就是等同于 signed int
。
数据类型的取值范围
上述的数据类型很多,尤其数整型类型就有short
、int
、long
、long long
四种,为什么呢?
其实每一种数据类型有自己的取值范围,也就是存储的数值的最大值和最小值的区间,有了丰富的类型,我们就可以在适当的场景下去选择适合的类型。如果要查看当前系统上不同数据类型的极限值: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 的最⼤值。
变量
变量的创建
了解清楚了类型,我们使用类型做什么呢?类型是用来创建变量的。
什么是变量呢?C语言中把经常变化的值称为变量,不变的值称为常量。
变量创建的语法形式是这样的:
data_type name;//数据类型 变量名
int age;//整型变量
char ch;//字符变量
double weight;//浮点型变量
在创建的时候就给一个初始值,就叫初始化。
int age = 15;
char ch = 'w';
double weight = 45.0;
unsigned int height = 100;
变量的分类
- 全局变量:在大括号外部定义的变量就是全局变量。全局变量的使用范围更广,整个工程中想使用,都是有办法使用的。
- 局部变量:在大括号内部定义的变量就是局部变量。局部变量的使用范围是比较局限,只能在自己所在的局部范围内使用的。
如果局部和全局变量,名字相同呢?
由上面的输出结果可以直到,当全局变量和局部变量名字相同时,局部变量优先使用。
全局变量和局部变量在内存中存储在哪⾥呢?
一般我们在学习C/C++语言的时候,我们会关注内存中的三个区域:栈区、堆区、静态区。
- 局部变量是放在内存的栈区
- 全局变量是放在内存的静态区
- 堆区是用来动态内存管理的
算数操作符:+、-、*、/、%
C语言中为了方便运算,提供了一系列操作符,其中有一组操作符叫:算术操作符。分别是: +
、-
、*
、/
、%
这些操作符都是双目操作符。
注:操作符也被叫做:运算符,是不同的翻译,意思是一样的。
+和-
+
和-
都是有2个操作数的,位于操作符两端的就是它们的操作数,这种操作符也叫双目操作符。
int main()
{
int x = 2 + 3;
int y = 10 - 3;
printf("%d\n", x);//5
printf("%d\n", y);//7
return 0;
}
*
int main()
{
int num = 5;
printf("%d\n", num * num);//25
return 0;
}
/
除号的两端如果是整数,执行的是整数除法,得到的结果也是整数。
int main()
{
float x = 6 / 4;
int y = 6 / 4;
printf("%f\n", x);
printf("%d\n", y);
return 0;
}
输出结果如下:
上面示例中,尽管变量 x
的类型是 float
(浮点数),但是 6 / 4
得到的结果是 1.0
,⽽不是
1.5
。原因就在于 C 语⾔⾥⾯的整数除法是整除,只会返回整数部分,丢弃小数部分。
如果希望得到浮点数的结果,两个运算数必须至少有一个浮点数,这时 C 语言就会进行浮点数除法。如下的可以验证。
下面再看一个例子:
int main()
{
int score = 5;
score = (score / 20) * 100;
printf("%d\n", score);
return 0;
}
你可能认为他运行的结果是25,但实际上是0,原因在于,score/20
是整除,得0,0乘100还是0。
要想得到预期效果,只需将20
改为20.0
即可。
%
运算符 %
表示求模运算,即返回两个整数相除的余值。这个运算符只能用于整数,不能用于浮点数。
int main()
{
int x = 8 % 3;
printf("%d\n", x);
return 0;
}
运行结果如下:
负数求模的规则是,结果的正负号由第一个运算数的正负号决定。
下面得例子可以说明这一点:
#include <stdio.h>
int main()
{
printf("%d\n", 11 % -5);
printf("%d\n", -11 % -5);
printf("%d\n", -11 % 5);
return 0;
}
赋值操作符:=和复合赋值
在变量创建的时候给一个初始值叫初始化,在变量创建好后,再给一个值,这叫赋值。
int a=0;//初始化
a=100;//赋值,这里使用的就是赋值操作符
连续赋值
赋值操作符也可以连续赋值,如:
int a=3;
int b=5;
int c=8;
c=b=a+6;//连续赋值,从右向左依次赋值
这样的代码语法没有错误,但是不易理解,不建议这样写,建议拆开写。
int a=3;
int b=5;
int c=8;
b=a+6;
c=b;
这样写,在调试的是,每一次赋值的细节都是可以很方便的观察的。
复合赋值符
在写代码时,我们经常可能对一个数进行自增、自减的操作,如下代码:
int a=10;
a=a+3;
a=a-4;
这样代码C语言给提供了更加方便的写法:
int a=10;
a+=3;
a-=4;
C语言中提供了复合赋值符,方便我们编写代码,这些赋值符有:
+= -=
*= /= %=
>>= <<=
&= |= ^=
单目操作符:++、--
、+、-
前面介绍的操作符都是双目操作符,有2个操作数的。C语言中还有一些操作符只有一个操作数,被称为单目操作符。 ++
、--
、+
(正)、-
(负) 就是单目操作符的。
++和–
++
是一种自增的操作符,又分为前置++
和后置++
,--
是一种自减的操作符,也分为前置--
和后置--
.
前置++
int a = 10;
int b=++a;//++的操作数是a,放在a的前面,是前置++
printf("a=%d b=%d\n",a,b);
a
原来是10
,先+1
,后a
变成了11
,再使用就是赋值给b
,b
得到的也是11
,所以计算后,a
和b
都是11
。
口诀:前置++
,先+1
,后使用。
后置++
int main()
{
int a = 10;
int b = a++;//++的操作数是a,放在a的后面,是后置++
printf("a=%d b=%d\n", a, b);
return 0;
}
a
原来是10
,先赋值给b
,b
得到10
,然后a
再+1
,a
得11
,所以计算后,a
是11
,b
是10
。
口诀:后置++
,先使用,后+1
。
前置--
int main()
{
int a = 10;
int b =--a;
printf("a=%d b=%d\n", a, b);
return 0;
}
口诀:前置--
,先-1
,后使用。
后置--
int main()
{
int a = 10;
int b = a--;
printf("a=%d b=%d\n", a, b);
return 0;
}
口诀:后置--
,先使用,后-1
。
+和-
这⾥的+是正号,-是负号,都是单目操作符。
运算符 + 对正负值没有影响,是一个完全可以省略的运算符,但是写了也不会报错。
int a=+10;
//等同于int a=10;
运算符-
⽤来改变一个值的正负号,负数的前面加上-
就会得到正数,正数的前面加上-
会得到负数。
强制类型转换
在操作符中还有一种特殊的操作符是强制类型转换,语法形式很简单,形式如下:
(类型)
int a=3.14;
//a是int类型,3.14是double类型,两边类型不一致,编译器会报警告。
为了消除这个警告,我们可以使用强制类型转换:
int a=(int)3.14;
//意思是将3.14强制类型转换为int类型,这种强制类型转换只取整数部分。
我们使用强制类型转换都是万不得已的时候使用,如果不需要强制类型转化就能实现代码,这样自然更好。
printf和scanf介绍
printf
基本用法
printf()
的作用是将参数文本输出到屏幕。它名字里面的 f 代表 format (格式化),表示可以定制输出文本的格式。
printf()
不会在行尾自动添加换行符,运行行结束后,光标就停留在输出结束的地方,不会自动换行。
为了让光标移到下一行的开头,可以在输出文本的结尾,添加一个换行符 \n
。
如果文本内部有换行,也是通过插入换行符来实现。
printf()
是在标准库的头文件stdio.h
定义的。使用这个函数之前,必须在源码文件头部引入这个头文件。
占位符
printf()
可以在输出⽂本中指定占位符。
所谓 “占位符”,就是这个位置可以⽤其他值代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()
允许限定占位符的最⼩宽度。
int main()
{
printf("%d\n", 12345);
printf("%4d\n", 123);
printf("%5d\n", 123);
return 0;
}
%4d
表⽰这个占位符的宽度⾄少为4位。如果不满4位,对应的值的前⾯会添加空格。
%5d
表⽰这个占位符的宽度⾄少为5位。如果不满5位,对应的值的前⾯会添加空格。
输出的值默认是右对齐,即输出内容前⾯会有空格;
如果希望改成左对⻬,在输出内容后⾯添加空格,可以在占位符的%
的后⾯插⼊⼀个-
号。
int main()
{
printf("%d\n", 12345);
printf("%5d\n", 123);
printf("%-5d\n", 123);
return 0;
}
对于⼩数,这个限定符会限制所有数字的最⼩显⽰宽度。
int main()
{
printf("%f\n", 123.14);
printf("%12f\n", 123.14);
return 0;
}
上⾯⽰例中%12f
表⽰输出的浮点数最少要占据12位。由于⼩数的默认显⽰精度是⼩数点后6位,所以123.14
输出结果的头部会添加2个空格。.
也算一位。
总是显示正负号
默认情况下, printf()
不对正数显⽰+
号,只对负数显⽰-
号。如果想让正数也输出 +
号,可以在占位符的%
后⾯加⼀个 +
。
int main()
{
printf("%d\n", 12);
printf("%+d\n", 12);
printf("%+d\n", -12);
return 0;
}
限定小数位数
输出⼩数时,有时希望限定⼩数的位数。举例来说,希望⼩数点后⾯只保留两位,占位符可以写成%.2f
。
int main()
{
printf("%f\n", 10.123);
printf("%.1f\n", 10.123);
printf("%.2f\n", 10.123);
printf("%.3f\n", 10.123);
return 0;
}
这种写法可以与限定宽度占位符,结合使⽤。
int main()
{
printf("%f\n", 0.5);
printf("%3f\n", 0.5);
printf("%.2f\n", 0.5);
printf("%3.2f\n", 0.5);
return 0;
}
最⼩宽度和⼩数位数这两个限定值,都可以⽤ *
代替,通过printf()
的参数传⼊。
int main()
{
printf("%*.*f\n", 6, 2, 0.5);
printf("%6.2f\n", 0.5);
return 0;
}
输出部分字符串
%s
占位符⽤来输出字符串,默认是全部输出。如果只想输出开头的部分,可以⽤%.[m]s
指定输出的⻓度,其中[m]
代表⼀个数字,表⽰所要输出的⻓度。
int main()
{
printf("%.5s\n", "helloworld");
return 0;
}
上⾯⽰例中,占位符%.5s
表⽰只输出字符串“hello world”
的前5个字符,即hello
。
scanf
当我们有了变量,我们需要给变量输⼊值就可以使⽤scanf
函数,如果需要将变量的值输出在屏幕上的时候可以使⽤ prinf
函数,下⾯看⼀个例⼦:
int main()
{
int score = 0;
printf("请输入成绩。\n");
scanf("%d", &score);
printf("成绩是:%d\n", score);
return 0;
}
基本用法
scanf()
函数用于读取用户的键盘输⼊。- 程序运⾏到这个语句时,会停下来,等待用户从键盘输⼊。
- 用户输⼊数据、按下回⻋键后,
scanf()
就会处理用户的输⼊,将其存⼊变量。 - 它的原型定义在头⽂件
stdio.h
。 scanf()
的语法跟printf()
类似。
scanf("%d",&i);
它的第⼀个参数是⼀个格式字符串,⾥⾯会放置占位符(与 printf()
的占位符基本⼀致),告诉编译器如何解读用户的输⼊,需要提取的数据是什么类型。
这是因为 C 语⾔的数据都是有类型的, scanf()
必须提前知道用户输⼊的数据类型,才能处理数据。
它的其余参数就是存放用户输⼊的变量,格式字符串⾥⾯有多少个占位符,就有多少个变量。
上⾯示例中, scanf()
的第⼀个参数 %d
,表示用户输⼊的应该是⼀个整数。 %d
就是⼀个占位符, %
是占位符的标志, d
表⽰整数。第⼆个参数 &i
表示,将用户从键盘输⼊的整数存⼊变量i
。
注意:变量前⾯必须加上 &
运算符(指针变量除外),因为 scanf()
传递的不是值,⽽是地址,即将变量i
的地址指向用户输⼊的值。
如果这⾥的变量是指针变量(⽐如字符串变量),那就不⽤加 &
运算符。
下⾯是⼀次将键盘输⼊读⼊多个变量的例⼦。
scanf("%d%d%f%f",&i,&j,&k,&l)
scanf()
处理数值占位符时,会⾃动过滤空⽩字符,包括空格、制表符、换行符等。
所以,用户输⼊的数据之间,有⼀个或多个空格不影响 scanf()
解读数据。另外,用户使⽤回⻋键,将输⼊分成⼏⾏,也不影响解读。
上⾯⽰例中,用户分成四⾏输⼊,得到的结果与⼀⾏输⼊是完全⼀样的。每次按下回⻋键以后,scanf()
就会开始解读,如果第⼀⾏匹配第⼀个占位符,那么下次按下回⻋键时,就会从第二个占位符开始解读。
scanf()
处理用户输⼊的原理是,用户的输⼊先放⼊缓存,等到按下回⻋键后,按照占位符对缓存进⾏解读。
解读用户输⼊时,会从上⼀次解读遗留的第⼀个字符开始,直到读完缓存,或者遇到第⼀个不符合条件的字符为⽌。
int main()
{
int x = 0;
float y = 0;
scanf("%d", &x);
printf("%d\n", x);
scanf("%f", &y);
printf("%f\n", y);
return 0;
}
上面示例中, scanf()
读取⽤⼾输⼊时, %d
占位符会忽略起⾸的空格,从 -
处开始获取数据,读取到 -13
停下来,因为后⾯的 . 不属于整数的有效字符。这就是说,占位符 %d
会读到-13
。
第⼆次调⽤ scanf()
时,就会从上⼀次停⽌解读的地⽅,继续往下读取。这⼀次读取的⾸字符是 .
,由于对应的占位符是 %f
,会读取到 .45e12
,这是采⽤科学计数法的浮点数格式。后⾯的#
不属于浮点数的有效字符,所以会停在这里。
由于 scanf()
可以连续处理多个占位符,所以上面的例子也可以写成下面这样:
int main()
{
int x = 0;
float y = 0;
scanf("%d%f", &x, &y);
printf("%d\n%f", x, y);
return 0;
}
scanf的返回值
scanf()
的返回值是一个整数,表示成功读取的变量个数。- 如果没有读取任何项,或者匹配失败,则返回
0
。 - 如果在成功读取任何数据之前,发生了读取错误或者遇到读取到文件结尾,则返回常量
EOF
。
int main()
{
int x = 0;
int y = 0;
float z = 0;
int ret=scanf("%d%d%f", &x, &y, &z);
printf("%d %d %f\n", x, y, z);
printf("ret=%d\n", ret);
return 0;
}
- 正常的输入三个数后,
scanf
的返回值是3,是正常读取的个数
- 正常输入两个返回值后,按
ctrl+z
,回车,提前结束输入,则返回值为2,表示正确读取了两个数值。
- 如果一个数字都不输入,直接按3次
ctrl+z
,返回值ret
是-1
,也就是EOF
。
占位符
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]
是⼀个整数,表示读取字符串的最大长度,后面的字符将被丢弃。
int main()
{
char name[11];
scanf("%10s", name);
//数组名本身即使地址,所以不用&取地址
return 0;
}
上面示例中, name
是一个长度为11的字符数组, scanf()
的占位符 %10s
表示最多读取用户输入的10个字符,后面的字符将被丢弃,这样就不会有数组溢出的风险了。
赋值忽略符
有时,用户的输入可能不符合预定的格式。
int main()
{
int year = 0;
int month = 0;
int day = 0;
scanf("%d-%d-%d", &year, &month, &day);
printf("%d %d %d\n", year, month, day);
return 0;
}
上面示例中,如果用户输入2020-01-01
,就会正确解读出年、月、日。问题是用户可能输入其他格式,比如2020/01/01
,这种情况下, scanf()
解析数据就会失败。
为了避免这种情况, scanf()
提供了⼀个赋值忽略符(assignment suppression character)*
只要把*
加在任何占位符的百分号后面,该占位符就不会返回值,解析后将被丢弃。
int main()
{
int year = 0;
int month = 0;
int day = 0;
scanf("%d%*c%d%*c%d", &year, &month, &day);
printf("%d %d %d\n", year, month, day);
return 0;
}
上面示例中, %*c
就是在占位符的百分号后面,加⼊了赋值忽略符*
,表示这个占位符没有对应的变量,解读后不必返回。