C语言数据类型

2. 数据类型

2.1 常量与变量

2.1.1 关键字

2.1.2 数据类型

数据类型的作用：编译器预算对象（变量）分配的内存空间大小。

2.1.3 常量

常量：

l  在程序运行过程中，其值不能被改变的量

l  常量一般出现在表达式或赋值语句中

整型常量	100，200，-100，0
实型常量	3.14 ， 0.125，-3.123
字符型常量	‘a’,‘b’,‘1’,‘\n’
字符串常量	“a”,“ab”，“12356”

2.1.4 变量

1) 变量

变量：

l  在程序运行过程中，其值可以改变

l  变量在使用前必须先定义，定义变量前必须有相应的数据类型

标识符命名规则：

l  标识符不能是关键字

l  标识符只能由字母、数字、下划线组成

l  第一个字符必须为字母或下划线

l  标识符中字母区分大小写

变量特点：

l  变量在编译时为其分配相应的内存空间

l  可以通过其名字和地址访问相应内存

2) 声明和定义区别

l  声明变量不需要建立存储空间，如：extern int a;

l  定义变量需要建立存储空间，如：int b;

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        //extern 关键字只做声明，不能做任何定义，后面还会学习，这里先了解
10 
11        //声明一个变量a，a在这里没有建立存储空间
12 
13        extern int a;
14 
15        a = 10;   //err, 没有空间，就不可以赋值
16 
17  
18 
19        int b = 10;     //定义一个变量b，b的类型为int，b赋值为10
20 
21  
22 
23        return 0;
24 
25 }      

从广义的角度来讲声明中包含着定义，即定义是声明的一个特例，所以并非所有的声明都是定义：

l  int b 它既是声明，同时又是定义

l  对于 extern b来讲它只是声明不是定义

一般的情况下，把建立存储空间的声明称之为“定义”，而把不需要建立存储空间的声明称之为“声明”。

2.1.5 使用示例

1 #include <stdio.h>
 2 
 3 #define MAX 10 //声明了一个常量，名字叫MAX，值是10，常量的值一旦初始化不可改
 4 
 5  
 6 
 7 int main()
 8 
 9 {
10 
11        int a;      //定义了一个变量，其类型为int，名字叫a
12 
13  
14 
15        const int b = 10; //定义一个const常量，名为叫b，值为10
16 
17        //b = 11; //err,常量的值不能改变
18 
19  
20 
21        //MAX = 100;     //err,常量的值不能改变
22 
23  
24 
25        a = MAX;//将abc的值设置为MAX的值
26 
27        a = 123;
28 
29  
30 
31        printf("%d\n", a); //打印变量a的值
32 
33  
34 
35        return 0;
36 
37 }
38 
39        

2.2 进制

进制也就是进位制，是人们规定的一种进位方法。 对于任何一种进制—X进制，就表示某一位置上的数运算时是逢X进一位。 十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。

十进制	二进制	八进制	十六进制
1	1	1	1
2	10	2	2
3	11	3	3
4	100	4	4
5	101	5	5
6	110	6	6
7	111	7	7
8	1000	10	8
9	1001	11	9
10	1010	12	A
11	1011	13	B
12	1100	14	C
13	1101	15	D
14	1110	16	E
15	1111	17	F
16	10000	20	10

2.2.1 二进制

二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”。

当前的计算机系统使用的基本上是二进制系统，数据在计算机中主要是以补码的形式存储的。

术语	含义
bit(比特)	一个二进制代表一位，一个位只能表示0或1两种状态。数据传输是习惯以“位”（bit）为单位。
Byte(字节)	一个字节为8个二进制，称为8位，计算机中存储的最小单位是字节。数据存储是习惯以“字节”（Byte）为单位。
WORD(双字节)	2个字节，16位
DWORD	两个WORD，4个字节，32位
1b	1bit，1位
1B	1Byte,1字节，8位
1k，1K	1024
1M(1兆)	1024k, 1024*1024
1G	1024M
1T	1024G
1Kb(千位)	1024bit,1024位
1KB(千字节)	1024Byte，1024字节
1Mb(兆位)	1024Kb = 1024 * 1024bit
1MB(兆字节)	1024KB = 1024 * 1024Byte

十进制转化二进制的方法：用十进制数除以2，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果。

十进制的小数转换成二进制：小数部分和2相乘，取整数，不足1取0，每次相乘都是小数部分，顺序看取整后的数就是转化后的结果。

2.2.2 八进制

八进制，Octal，缩写OCT或O，一种以8为基数的计数法，采用0，1，2，3，4，5，6，7八个数字，逢八进1。一些编程语言中常常以数字0开始表明该数字是八进制。

八进制的数和二进制数可以按位对应（八进制一位对应二进制三位），因此常应用在计算机语言中。

十进制转化八进制的方法：

用十进制数除以8，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果。

2.2.3 十六进制

十六进制（英文名称：Hexadecimal），同我们日常生活中的表示法不一样，它由0-9，A-F组成，字母不区分大小写。与10进制的对应关系是：0-9对应0-9，A-F对应10-15。

十六进制的数和二进制数可以按位对应（十六进制一位对应二进制四位），因此常应用在计算机语言中。

十进制转化十六进制的方法：

用十进制数除以16，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果。

2.2.4 C语言如何表示相应进制数

十进制	以正常数字1-9开头，如123
八进制	以数字0开头，如0123
十六进制	以0x开头，如0x123
二进制	C语言不能直接书写二进制数

1  
 2 
 3 #include <stdio.h>
 4 
 5  
 6 
 7 int main()
 8 
 9 {
10 
11        int a = 123;          //十进制方式赋值
12 
13        int b = 0123;        //八进制方式赋值， 以数字0开头
14 
15        int c = 0xABC;   //十六进制方式赋值
16 
17  
18 
19        //如果在printf中输出一个十进制数那么用%d，八进制用%o，十六进制是%x
20 
21        printf("十进制：%d\n",a );
22 
23        printf("八进制：%o\n", b); //%o,为字母o,不是数字
24 
25        printf("十六进制：%x\n", c);
26 
27  
28 
29        return 0;
30 
31 }
32 
33        

2.3 计算机内存数值存储方式

2.3.1 原码

一个数的原码(原始的二进制码)有如下特点：

l  最高位做为符号位，0表示正,为1表示负

l  其它数值部分就是数值本身绝对值的二进制数

l  负数的原码是在其绝对值的基础上，最高位变为1

下面数值以1字节的大小描述：

十进制数	原码
+15	0000 1111
-15	1000 1111
+0	0000 0000
-0	1000 0000

原码表示法简单易懂，与带符号数本身转换方便，只要符号还原即可，但当两个正数相减或不同符号数相加时，必须比较两个数哪个绝对值大，才能决定谁减谁，才能确定结果是正还是负，所以原码不便于加减运算。

2.3.2 反码

l  对于正数，反码与原码相同

l  对于负数，符号位不变，其它部分取反(1变0,0变1)

十进制数	反码
+15	0000 1111
-15	1111 0000
+0	0000 0000
-0	1111 1111

反码运算也不方便，通常用来作为求补码的中间过渡。

2.3.3 补码

在计算机系统中，数值一律用补码来存储。

补码特点：

l  对于正数，原码、反码、补码相同

l  对于负数，其补码为它的反码加1

l  补码符号位不动，其他位求反，最后整个数加1，得到原码

十进制数	补码
+15	0000 1111
-15	1111 0001
+0	0000 0000
-0	0000 0000

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        int  a = -15;
10 
11  
12 
13        printf("%x\n", a);
14 
15        //结果为 fffffff1
16 
17        //fffffff1对应的二进制：1111 1111 1111 1111 1111 1111 1111 0001
18 
19        //符号位不变，其它取反：1000 0000 0000 0000 0000 0000 0000 1110
20 
21        //上面加1：1000 0000 0000 0000 0000 0000 0000 1111  最高位1代表负数，就是-15
22 
23  
24 
25        return 0;
26 
27 }
28 
29        

2.3.4 补码的意义

示例1：用8位二进制数分别表示+0和-0

十进制数	原码
+0	0000 0000
-0	1000 0000

十进制数	反码
+0	0000 0000
-0	1111 1111

不管以原码方式存储，还是以反码方式存储，0也有两种表示形式。为什么同样一个0有两种不同的表示方法呢？

但是如果以补码方式存储，补码统一了零的编码：

十进制数	补码
+0	0000 0000
-0	10000 0000由于只用8位描述，最高位1丢弃，变为0000 0000

示例2：计算9-6的结果

以原码方式相加：

十进制数	原码
9	0000 1001
-6	1000 0110

结果为-15，不正确。

以补码方式相加：

十进制数	补码
9	0000 1001
-6	1111 1010

最高位的1溢出,剩余8位二进制表示的是3，正确。

在计算机系统中，数值一律用补码来存储，主要原因是：

l  统一了零的编码

l  将符号位和其它位统一处理

l  将减法运算转变为加法运算

l  两个用补码表示的数相加时，如果最高位(符号位)有进位，则进位被舍弃

2.4 sizeof关键字

l  sizeof不是函数，所以不需要包含任何头文件，它的功能是计算一个数据类型的大小，单位为字节

l  sizeof的返回值为size_t

l  size_t类型在32位操作系统下是unsigned int，是一个无符号的整数

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        int a;
10 
11        int b = sizeof(a);//sizeof得到指定值占用内存的大小，单位：字节
12 
13        printf("b = %d\n", b);
14 
15  
16 
17        size_t c = sizeof(a);
18 
19        printf("c = %u\n", c);//用无符号数的方式输出c的值
20 
21  
22 
23        return 0;
24 
25 }      

2.5整型：int

2.5.1 整型变量的定义和输出

打印格式	含义
%d	输出一个有符号的10进制int类型
%o(字母o)	输出8进制的int类型
%x	输出16进制的int类型，字母以小写输出
%X	输出16进制的int类型，字母以大写写输出
%u	输出一个10进制的无符号数

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        int a = 123;   //定义变量a，以10进制方式赋值为123
10 
11        int b = 0567; //定义变量b，以8进制方式赋值为0567
12 
13        int c = 0xabc;      //定义变量c，以16进制方式赋值为0xabc
14 
15  
16 
17        printf("a = %d\n", a);
18 
19        printf("8进制：b = %o\n", b);
20 
21        printf("10进制：b = %d\n", b);
22 
23        printf("16进制：c = %x\n", c);
24 
25        printf("16进制：c = %X\n", c);
26 
27        printf("10进制：c = %d\n", c);
28 
29  
30 
31        unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
32 
33        printf("有符号方式打印：d = %d\n", d);
34 
35        printf("无符号方式打印：d = %u\n", d);
36 
37        return 0;
38 
39 }      

2.5.2 整型变量的输入

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        int a;
10 
11        printf("请输入a的值：");
12 
13  
14 
15        //不要加“\n”
16 
17        scanf("%d", &a);
18 
19  
20 
21        printf("a = %d\n", a); //打印a的值
22 
23  
24 
25        return 0;
26 
27 }      

2.5.3 short、int、long、long long

数据类型	占用空间
short(短整型)	2字节
int(整型)	4字节
long(长整形)	Windows为4字节，Linux为4字节(32位)，8字节(64位)
long long(长长整形)	8字节

注意：

l  需要注意的是，整型数据在内存中占的字节数与所选择的操作系统有关。虽然 C 语言标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型， short 类型整数的长度不能短于 int 类型。

l  当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。但当一个大的类型赋值给一个小的数据类型，那么就可能丢失高位。

整型常量	所需类型
10	代表int类型
10l, 10L	代表long类型
10ll, 10LL	代表long long类型
10u, 10U	代表unsigned int类型
10ul, 10UL	代表unsigned long类型
10ull, 10ULL	代表unsigned long long类型

打印格式	含义
%hd	输出short类型
%d	输出int类型
%l	输出long类型
%ll	输出long long类型
%hu	输出unsigned short类型
%u	输出unsigned int类型
%lu	输出unsigned long类型
%llu	输出unsigned long long类型

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        short a = 10;
10 
11        int b = 10;
12 
13        long c = 10l; //或者10L
14 
15        long long d = 10ll; //或者10LL
16 
17  
18 
19        printf("sizeof(a) = %u\n", sizeof(a));
20 
21        printf("sizeof(b) = %u\n", sizeof(b));
22 
23        printf("sizeof(c) = %u\n", sizeof(c));
24 
25        printf("sizeof(c) = %u\n", sizeof(d));
26 
27  
28 
29        printf("short a = %hd\n", a);
30 
31        printf("int b = %d\n", b);
32 
33        printf("long c = %ld\n", c);
34 
35        printf("long long d = %lld\n", d);
36 
37  
38 
39        unsigned short a2 = 20u;
40 
41        unsigned int b2 = 20u;
42 
43        unsigned long c2= 20ul;
44 
45        unsigned long long d2 = 20ull;
46 
47  
48 
49        printf("unsigned short a = %hu\n", a2);
50 
51        printf("unsigned int b = %u\n", b2);
52 
53        printf("unsigned long c = %lu\n", c2);
54 
55        printf("unsigned long long d = %llu\n", d2);
56 
57  
58 
59        return 0;
60 
61 }
62 
63        

2.5.4 有符号数和无符号数区别

1) 有符号数

有符号数是最高位为符号位，0代表正数，1代表负数。

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        signed int a = -1089474374; //定义有符号整型变量a
10 
11        printf("%X\n", a); //结果为 BF0FF0BA
12 
13  
14 
15        //B       F      0        F       F     0        B           A
16 
17        //1011 1111 0000 1111 1111 0000 1011 1010
18 
19  
20 
21        return 0;
22 
23 }
24 
25        

2) 无符号数

无符号数最高位不是符号位，而就是数的一部分，无符号数不可能是负数。

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        unsigned int a = 3236958022; //定义无符号整型变量a
10 
11        printf("%X\n", a); //结果为 C0F00F46
12 
13  
14 
15        return 0;
16 
17 }      

当我们写程序要处理一个不可能出现负值的时候，一般用无符号数，这样可以增大数的表达最大值。

3) 有符号和无符号整型取值范围

数据类型	占用空间	取值范围
short	2字节	-32768 到 32767 (-215 ~ 215-1)
int	4字节	-2147483648 到 2147483647 (-231 ~ 231-1)
long	4字节	-2147483648 到 2147483647 (-231 ~ 231-1)
unsigned short	2字节	0 到 65535 (0 ~ 216-1)
unsigned int	4字节	0 到 4294967295 (0 ~ 232-1)
unsigned long	4字节	0 到 4294967295 (0 ~ 232-1)

2.6字符型：char

2.6.1 字符变量的定义和输出

字符型变量用于存储一个单一字符，在 C 语言中用 char 表示，其中每个字符变量都会占用 1 个字节。在给字符型变量赋值时，需要用一对英文半角格式的单引号(' ')把字符括起来。

字符变量实际上并不是把该字符本身放到变量的内存单元中去，而是将该字符对应的 ASCII 编码放到变量的存储单元中。char的本质就是一个1字节大小的整型。

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        char ch = 'a';
10 
11        printf("sizeof(ch) = %u\n", sizeof(ch));
12 
13  
14 
15        printf("ch[%%c] = %c\n", ch); //打印字符
16 
17        printf("ch[%%d] = %d\n", ch); //打印‘a’ ASCII的值
18 
19  
20 
21        char A = 'A';
22 
23        char a = 'a';
24 
25        printf("a = %d\n", a);        //97
26 
27        printf("A = %d\n", A);      //65
28 
29  
30 
31        printf("A = %c\n", 'a' - 32); //小写a转大写A
32 
33        printf("a = %c\n", 'A' + 32); //大写A转小写a
34 
35  
36 
37        ch = ' ';
38 
39        printf("空字符：%d\n", ch); //空字符ASCII的值为32
40 
41        printf("A = %c\n", 'a' - ' '); //小写a转大写A
42 
43        printf("a = %c\n", 'A' + ' '); //大写A转小写a
44 
45  
46 
47        return 0;
48 
49 }
50 
51        

2.6.2 字符变量的输入

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        char ch;
10 
11        printf("请输入ch的值：");
12 
13  
14 
15        //不要加“\n”
16 
17        scanf("%c", &ch);
18 
19        printf("ch = %c\n", ch); //打印ch的字符
20 
21  
22 
23        return 0;
24 
25 }      

2.6.2 ASCII对照表

ASCII值	控制字符	ASCII值	字符	ASCII值	字符	ASCII值	字符
NUT	32	(space)	64	@	96	、
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124	|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	`
31	US	63	?	95	_	127	DEL

ASCII 码大致由以下两部分组成：

l  ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。

l  ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。数字 127 代表 Del 命令。

2.6.3 转义字符

转义字符	含义	ASCII码值（十进制）
\a	警报	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符"\"	092
\'	代表一个单引号（撇号）字符	039
\"	代表一个双引号字符	034
\?	代表一个问号	063
\0	数字0	000
\ddd	8进制转义字符，d范围0~7	3位8进制
\xhh	16进制转义字符，h范围0~9，a~f，A~F	3位16进制

注意：红色字体标注的为不可打印字符。

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        printf("abc");
10 
11        printf("\refg\n"); //\r切换到句首， \n为换行键
12 
13  
14 
15        printf("abc");
16 
17        printf("\befg\n");//\b为退格键， \n为换行键
18 
19  
20 
21        printf("%d\n", '\123');// '\123'为8进制转义字符，0123对应10进制数为83
22 
23        printf("%d\n", '\x23');// '\x23'为16进制转义字符，0x23对应10进制数为35
24 
25  
26 
27        return 0;
28 
29 }      

2.6.4 数值溢出

当超过一个数据类型能够存放最大的范围时，数值会溢出。

有符号位最高位溢出的区别：符号位溢出会导致数的正负发生改变，但最高位的溢出会导致最高位丢失。

数据类型	占用空间	取值范围
char	1字节	-128到 127(-27 ~ 27-1)
unsigned char	1字节	0 到 255(0 ~ 28-1)

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        char ch;
10 
11  
12 
13        //符号位溢出会导致数的正负发生改变
14 
15        ch = 0x7f + 2; //127+2
16 
17        printf("%d\n", ch);
18 
19        //     0111 1111
20 
21        //+2后 1000 0001，这是负数补码，其原码为 1111 1111，结果为-127
22 
23  
24 
25        //最高位的溢出会导致最高位丢失
26 
27        unsigned char ch2;
28 
29        ch2 = 0xff+1; //255+1
30 
31        printf("%u\n", ch2);
32 
33        //       1111 1111
34 
35        //+1后 10000 0000， char只有8位最高位的溢出，结果为0000 0000，十进制为0
36 
37  
38 
39        ch2 = 0xff + 2; //255+1
40 
41        printf("%u\n", ch2);
42 
43        //       1111 1111
44 
45        //+1后 10000 0001， char只有8位最高位的溢出，结果为0000 0001，十进制为1
46 
47  
48 
49        return 0;
50 
51 }
52 
53        

2.7实型(浮点型)：float、double

实型变量也可以称为浮点型变量，浮点型变量是用来存储小数数值的。在C语言中， 浮点型变量分为两种： 单精度浮点数(float)、 双精度浮点数(double)， 但是double型变量所表示的浮点数比 float 型变量更精确。

数据类型	占用空间	有效数字范围
float	4字节	7位有效数字
double	8字节	15～16位有效数字

由于浮点型变量是由有限的存储单元组成的，因此只能提供有限的有效数字。在有效位以外的数字将被舍去，这样可能会产生一些误差。

不以f结尾的常量是double类型，以f结尾的常量(如3.14f)是float类型。

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        //传统方式赋值
10 
11        float a = 3.14f; //或3.14F
12 
13        double b = 3.14;
14 
15  
16 
17        printf("a = %f\n", a);
18 
19        printf("b = %lf\n", b);
20 
21  
22 
23        //科学法赋值
24 
25        a = 3.2e3f; //3.2*1000 = 32000，e可以写E
26 
27        printf("a1 = %f\n", a);
28 
29  
30 
31        a = 100e-3f; //100*0.001 = 0.1
32 
33        printf("a2 = %f\n", a);
34 
35  
36 
37        a = 3.1415926f;
38 
39        printf("a3 = %f\n", a); //结果为3.141593
40 
41  
42 
43        return 0;
44 
45 }
46 
47        

2.8类型限定符

限定符	含义
extern	声明一个变量，extern声明的变量没有建立存储空间。 extern int a;
const	定义一个常量，常量的值不能修改。 const int a = 10;
volatile	防止编译器优化代码
register	定义寄存器变量，提高效率。register是建议型的指令，而不是命令型的指令，如果CPU有空闲寄存器，那么register就生效，如果没有空闲寄存器，那么register无效。

2.9字符串格式化输出和输入

2.9.1 字符串常量

l  字符串是内存中一段连续的char空间，以'\0'(数字0)结尾。

l  字符串常量是由双引号括起来的字符序列，如“china”、“C program”，“$12.5”等都是合法的字符串常量。

字符串常量与字符常量的不同：

每个字符串的结尾，编译器会自动的添加一个结束标志位'\0'，即 "a" 包含两个字符'a'和’\0’。

2.9.2 printf函数和putchar函数

printf是输出一个字符串，putchar输出一个char。

printf格式字符：

打印格式	对应数据类型	含义
%d	int	接受整数值并将它表示为有符号的十进制整数
%hd	short int	短整数
%hu	unsigned short	无符号短整数
%o	unsigned int	无符号8进制整数
%u	unsigned int	无符号10进制整数
%x,%X	unsigned int	无符号16进制整数，x对应的是abcdef，X对应的是ABCDEF
%f	float	单精度浮点数
%lf	double	双精度浮点数
%e,%E	double	科学计数法表示的数，此处"e"的大小写代表在输出时用的"e"的大小写
%c	char	字符型。可以把输入的数字按照ASCII码相应转换为对应的字符
%s	char *	字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符）
%p	void *	以16进制形式输出指针
%%	%	输出一个百分号

printf附加格式：

字符	含义
l(字母l)	附加在d,u,x,o前面，表示长整数
-	左对齐
m(代表一个整数)	数据最小宽度
0(数字0)	将输出的前面补上0直到占满指定列宽为止不可以搭配使用-
m.n(代表一个整数)	m指域宽，即对应的输出项在输出设备上所占的字符数。n指精度，用于说明输出的实型数的小数位数。对数值型的来说，未指定n时，隐含的精度为n=6位。

1 #include <stdio.h>
 2 
 3 int main()
 4 
 5 {
 6 
 7        int a = 100;
 8 
 9        printf("a = %d\n", a);//格式化输出一个字符串
10 
11        printf("%p\n", &a);//输出变量a在内存中的地址编号
12 
13        printf("%%d\n");
14 
15  
16 
17        char c = 'a';
18 
19        putchar(c);//putchar只有一个参数，就是要输出的char
20 
21        long a2 = 100;
22 
23        printf("%ld, %lx, %lo\n", a2, a2, a2);
24 
25  
26 
27        long long a3 = 1000;
28 
29        printf("%lld, %llx, %llo\n", a3, a3, a3);
30 
31  
32 
33        int abc = 10;
34 
35        printf("abc = '%6d'\n", abc);
36 
37        printf("abc = '%-6d'\n", abc);
38 
39        printf("abc = '%06d'\n", abc);
40 
41        printf("abc = '%-06d'\n", abc);
42 
43  
44 
45        double d = 12.3;
46 
47        printf("d = \' %-10.3lf \'\n", d);
48 
49  
50 
51        return 0;
52 
53 }      

2.9.3 scanf函数与getchar函数

l  getchar是从标准输入设备读取一个char。

l  scanf通过%转义的方式可以得到用户通过标准输入设备输入的数据。

1 #include <stdio.h>
 2 
 3  
 4 
 5 int main()
 6 
 7 {
 8 
 9        char ch1;
10 
11        char ch2;
12 
13        char ch3;
14 
15        int a;
16 
17        int b;
18 
19  
20 
21        printf("请输入ch1的字符：");
22 
23        ch1 = getchar();
24 
25        printf("ch1 = %c\n", ch1);
26 
27  
28 
29        getchar(); //测试此处getchar()的作用
30 
31  
32 
33        printf("请输入ch2的字符：");
34 
35        ch2 = getchar();
36 
37        printf("\'ch2 = %ctest\'\n", ch2);
38 
39  
40 
41        getchar(); //测试此处getchar()的作用
42 
43        printf("请输入ch3的字符：");
44 
45        scanf("%c", &ch3);//这里第二个参数一定是变量的地址，而不是变量名
46 
47        printf("ch3 = %c\n", ch3);
48 
49  
50 
51        printf("请输入a的值：");
52 
53        scanf("%d", &a);
54 
55        printf("a = %d\n", a);
56 
57  
58 
59        printf("请输入b的值：");
60 
61        scanf("%d", &b);
62 
63        printf("b = %d\n", b);
64 
65  
66 
67        return 0;
68 
69 }      

十进制代码	十六进制代码	MCS 字符或缩写	DEC 多国字符名
ASCII 控制字符 1
NUL	空字符
1	1	SOH	标题起始 (Ctrl/A)
2	2	STX	文本起始 (Ctrl/B)
3	3	ETX	文本结束 (Ctrl/C)
4	4	EOT	传输结束 (Ctrl/D)
5	5	ENQ	询问 (Ctrl/E)
6	6	ACK	认可 (Ctrl/F)
7	7	BEL	铃 (Ctrl/G)
8	8	BS	退格 (Ctrl/H)
9	9	HT	水平制表栏 (Ctrl/I)
10	0A	LF	换行 (Ctrl/J)
11	0B	VT	垂直制表栏 (Ctrl/K)
12	0C	FF	换页 (Ctrl/L)
13	0D	CR	回车 (Ctrl/M)
14	0E	SO	移出 (Ctrl/N)
15	0F	SI	移入 (Ctrl/O)
16	10	DLE	数据链接丢失 (Ctrl/P)
17	11	DC1	设备控制 1 (Ctrl/Q)
18	12	DC2	设备控制 2 (Ctrl/R)
19	13	DC3	设备控制 3 (Ctrl/S)
20	14	DC4	设备控制 4 (Ctrl/T)
21	15	NAK	否定接受 (Ctrl/U)
22	16	SYN	同步闲置符 (Ctrl/V)
23	17	ETB	传输块结束 (Ctrl/W)
24	18	CAN	取消 (Ctrl/X)
25	19	EM	媒体结束 (Ctrl/Y)
26	1A	SUB	替换 (Ctrl/Z)
27	1B	ESC	换码符
28	1C	FS	文件分隔符
29	1D	GS	组分隔符
30	1E	RS	记录分隔符
31	1F	US	单位分隔符
ASCII 特殊和数字字符
32	20	SP	空格
33	21	!	感叹号
34	22	"	引号 (双引号)
35	23	#	数字符号
36	24	$	美元符
37	25	%	百分号
38	26	&	和号
39	27	'	省略号 (单引号)
40	28	(	左圆括号
41	29	)	右圆括号
42	2A	*	星号
43	2B	+	加号
44	2C	,	逗号
45	2D	--	连字号或减号
46	2E	.	句点或小数点
47	2F	/	斜杠
48	30	零
49	31	1	1
50	32	2	2
51	33	3	3
52	34	4	4
53	35	5	5
54	36	6	6
55	37	7	7
56	38	8	8
57	39	9	9
58	3A	:	冒号
59	3B	;	分号
60	3C	<	小于
61	3D	=	等于
62	3E	>	大于
63	3F	?	问号
ASCII 字母字符
64	40	@	商业 at 符号
65	41	A	大写字母 A
66	42	B	大写字母 B
67	43	C	大写字母 C
68	44	D	大写字母 D
69	45	E	大写字母 E
70	46	F	大写字母 F
71	47	G	大写字母 G
72	48	H	大写字母 H
73	49	I	大写字母 I
74	4A	J	大写字母 J
75	4B	K	大写字母 K
76	4C	L	大写字母 L
77	4D	M	大写字母 M
78	4E	N	大写字母 N
79	4F	O	大写字母 O
80	50	P	大写字母 P
81	51	Q	大写字母 Q
82	52	R	大写字母 R
83	53	S	大写字母 S
84	54	T	大写字母 T
85	55	U	大写字母 U
86	56	V	大写字母 V
87	57	W	大写字母 W
88	58	X	大写字母 X
89	59	Y	大写字母 Y
90	5A	Z	大写字母 Z
91	5B	[	左中括号
92	5C	\	反斜杠
93	5D	]	右中括号
94	5E	^	音调符号
95	5F	_	下划线
96	60	`	重音符
97	61	a	小写字母 a
98	62	b	小写字母 b
99	63	c	小写字母 c
100	64	d	小写字母 d
101	65	e	小写字母 e
102	66	f	小写字母 f
103	67	g	小写字母 g
104	68	h	小写字母 h
105	69	i	小写字母 i
106	6A	j	小写字母 j
107	6B	k	小写字母 k
108	6C	l	小写字母 l
109	6D	m	小写字母 m
110	6E	n	小写字母 n
111	6F	o	小写字母 o
112	70	p	小写字母 p
113	71	q	小写字母 q
114	72	r	小写字母 r
115	73	s	小写字母 s
116	74	t	小写字母 t
117	75	u	小写字母 u
118	76	v	小写字母 v
119	77	w	小写字母 w
120	78	x	小写字母 x
121	79	y	小写字母 y
122	7A	z	小写字母 z
123	7B	{	左大括号
124	7C	|	垂直线
125	7D	}	右大括号 (ALTMODE)
126	7E	~	代字号 (ALTMODE)
127	7F	DEL	擦掉 (DELETE)
控制字符
128	80		[保留]
129	81		[保留]
130	82		[保留]
131	83		[保留]
132	84	IND	索引
133	85	NEL	下一行
134	86	SSA	被选区域起始
135	87	ESA	被选区域结束
136	88	HTS	水平制表符集
137	89	HTJ	对齐的水平制表符集
138	8A	VTS	垂直制表符集
139	8B	PLD	部分行向下
140	8C	PLU	部分行向上
141	8D	RI	反向索引
142	8E	SS2	单移 2
143	8F	SS3	单移 3
144	90	DCS	设备控制字符串
145	91	PU1	专用 1
146	92	PU2	专用 2
147	93	STS	设置传输状态
148	94	CCH	取消字符
149	95	MW	消息等待
150	96	SPA	保护区起始
151	97	EPA	保护区结束
152	98		[保留]
153	99		[保留]
154	9A		[保留]
155	9B	CSI	控制序列引导符
156	9C	ST	字符串终止符
157	9D	OSC	操作系统命令
158	9E	PM	秘密消息
159	9F	APC	应用程序
其他字符
160	A0		[保留] 2
161	A1	¡	反向感叹号
162	A2	¢	分币符
163	A3	£	英磅符
164	A4		[保留] 2
165	A5	¥	人民币符
166	A6		[保留] 2
167	A7	§	章节符
168	A8	¤	通用货币符号 2
169	A9	©	版权符号
170	AA	ª	阴性顺序指示符
171	AB	«	左角引号
172	AC		[保留] 2
173	AD		[保留] 2
174	AE		[保留] 2
175	AF		[保留] 2
176	B0	°	温度符
177	B1	±	加/减号
178	B2	²	上标 2
179	B3	³	上标 3
180	B4		[保留] 2
181	B5	µ	微符
182	B6	¶	段落符，pilcrow
183	B7	·	中点
184	B8		[保留] 2
185	B9	¹	上标 1
186	BA	º	阳性顺序指示符
187	BB	»	右角引号
188	BC	¼	分数四分之一
189	BD	½	分数二分之一
190	BE		[保留] 2
191	BF	¿	反向问号
192	C0	À	带重音符的大写字母 A
193	C1	Á	带尖锐重音的大写字母 A
194	C2	Â	带音调符号的大写字母 A
195	C3	Ã	带代字号的大写字母 A
196	C4	Ä	带元音变音 (分音符号) 的大写字母 A
197	C5	Å	带铃声的大写字母 A
198	C6	Æ	大写字母 AE 双重元音
199	C7	Ç	带变音符号的大写字母 C
200	C8	È	带重音符的大写字母 E
201	C9	É	带尖锐重音的大写字母 E
202	CA	Ê	带音调符号的大写字母 E
203	CB	Ë	带元音变音 (分音符号) 的大写字母 E
204	CC	Ì	带重音符的大写字母 I
205	CD	Í	带尖锐重音的大写字母 I
206	CE	Î	带音调符号的大写字母 I
207	CF	Ï	带元音变音 (分音符号) 的大写字母 I
208	D0		[保留] 2
209	D1	Ñ	带代字号的大写字母 N
210	D2	Ò	带重音符的大写字母 O
211	D3	Ó	带尖锐重音的大写字母 O
212	D4	Ô	带音调符号的大写字母 O
213	D5	Õ	带代字号的大写字母 O
214	D6	Ö	带元音变音 (分音符号) 的大写字母 O
215	D7	OE	大写字母 OE 连字 2
216	D8	Ø	带斜杠的大写字母 O
217	D9	Ù	带重音符的大写字母 U
218	DA	Ú	带尖锐重音的大写字母 U
219	DB	Û	带音调符号的大写字母 U
220	DC	Ü	带元音变音 (分音符号) 的大写字母 U
221	DD	Y	带元音变音 (分音符号) 的大写字母 Y
222	DE		[保留] 2
223	DF	ß	德语高调小写字母 s
224	E0	à	带重音符的小写字母 a
225	E1	á	带尖锐重音的小写字母 a
226	E2	â	带音调符号的小写字母 a
227	E3	ã	带代字号的小写字母 a
228	E4	ä	带元音变音 (分音符号) 的小写字母 a
229	E5	å	带铃声的小写字母 a
230	E6	æ	小写字母 ae 双重元音
231	E7	ç	带变音符号的小写字母 c
232	E8	è	带重音符的小写字母 e
233	E9	é	带尖锐重音的小写字母 e
234	EA	ê	带音调符号的小写字母 e
235	EB	ë	带元音变音 (分音符号) 的小写字母 e
236	EC	ì	带重音符的小写字母 i
237	ED	í	带尖锐重音的小写字母 i
238	EE	î	带音调符号的小写字母 i
239	EF	ï	带元音变音 (分音符号) 的小写字母 i
240	F0		[保留] 2
241	F1	ñ	带代字号的小写字母 n
242	F2	ò	带重音符的小写字母 o
243	F3	ó	带尖锐重音的小写字母 o
244	F4	ô	带音调符号的小写字母 o
245	F5	õ	带代字号的小写字母 o
246	F6	ö	带元音变音 (分音符号) 的小写字母 o
247	F7	oe	小写字母 oe 连字 2
248	F8	ø	带斜杠的小写字母 o
249	F9	ù	带重音符的小写字母 u
250	FA	ú	带尖锐重音的小写字母 u
251	FB	û	带音调符号的小写字母 u
252	FC	ü	带元音变音 (分音符号) 的小写字母 u
253	FD	ÿ	带元音变音 (分音符号) 的小写字母 y 2
254	FE		[保留] 2
255	FF		[保留] 2

1、数据类型的定义

1、数据类型的定义 变量的定义： 数据类型 变量名【标识符】  变量的赋值： 变量名 = 值； 数据类型 变量名【标识符】 = 值   标示符的命名规则： 1、字母、数字、下划线 2、不能以数字开头 3、见名知义 4、不能和同一函数内的其他标示符重复 5、不能使用C语言关键字 6、区分大小写   标示符： ABC abc —abc _abc. 123_bac a_b_123   常量的定义： 1、const 数据类型 常量名 2、【宏定义】#deifne 常量名 值 注意： 1、通过#define 定义的常量 是根据值来匹配数据类型的 2、const 修饰的常量是不安全 可以通过指针来修改     2、进制： 二进制：      二进制逢二进一，所有的数组是0、1组成 十进制转二进制： 除二反序取余法：将十进制数每次除以2 取出余数 按照结果倒叙依次获取结果 二进制转十进制： 权值法：将二进制数各个位数从0位开始乘以2的N幂 将各个位数的结果相加 八进制：      八进制逢八进一，所有的数组是0到7组成 十进制转八进制： 除八反序取余法：将十进制数每次除以8 取出余数 按照结果倒叙依次获取结果   十六进制：      十六进制逢十六进一，所有的数组是0到9和A到F组成 字母不区分大小写 十进制转八进制： 除十六反序取余法：将十进制数每次除以16 取出余数 按照结果倒叙依次获取结果   8421法则： 将各个位数的二进制用十进制中的【数字 】来表示多位的二进制数 通过【数字 】相加就可以得到二进制数的数据 8 1000 4 100 2 10 1 1 1000   100     10       1 ———— 1 1 1 1   进制在程序中打印： int a=10;//十进制中的10 int b=010;//八进制中的10 在程序中定义一个八进制数需要在数前面加上0区分 int c=0x10;//十六进制中的10在程序中定义一个十六进制数需要在数前面加上0x区分 int d=0X10;//十六进制中的10在程序中定义一个十六进制数需要在数前面加上0X区分 注意：在程序中没有办法表示一个二进制数 %d 将数据按照十进制输出 %o将数据按照八进制输出 %x将数据按照十六进制小写输出 %X将数据按照十六进制大写输出   3、原码、反码、补码 一个有符号的整型数据可以分为两部分一部分是符号位、一部分是数字位 无符号数据类型只包含数字位部分 signed int a= 1986（有符号标识 signed可以不用写）  二进制：11111000010   1986原码：0000 0000 0000 0000 0000 0111 1100 0010 -1986原码：1000 0000 0000 0000 0000 0111 1100 0010   1986反码： 0000 0000 0000 0000 0000 0111 1100 0010 -1986反码：1111 1111 1111 1111 1111 1000 0011 1101   1986补码： 0000 0000 0000 0000 0000 0111 1100 0010 -1986反码：1111 1111 1111 1111 1111 1000 0011 1110                  1 0000 0000 0000 0000 0000 0000 0000 0000 溢出：在数据进行操作的时候会导致超出数据类型大小，会向前位进1，多于原始数据类型大小，会被系统自动舍弃 保留从后面开始数据类型大小的位数       10+20 0000 1010 0001 0100 0001 1110 -10+-20 原码：1000 1010 反码：1111 0101 补码：1111 0110   原码：1001 0100 反码：1110 1011 补码：1110 1100      1111 0110      1110 1100 补码：1110  0010 反码：1110 0001 原码：1001 1110 16+8+4+2=-30   练习：用生辰年份年去生辰日期 1992 -326 1、将10进制转化为二进制      1992 ：0000 0000 0000 0000 0000 0111 1100 1000      -326 ：0000 0000 0000 0000 0000 0001 0100 0110 2、加符号位将数据变为原码      1992 ：0000 0000 0000 0000 0000 0111 1100 1000      -326 ：1000 0000 0000 0000 0000 0001 0100 0110 3、转化为反码      1992 ：0000 0000 0000 0000 0000 0111 1100 1000      -326 ：1111 1111 1111 1111 1111 1110 1011 1001 4、将反码+1转化为补码      1992 ：0000 0000 0000 0000 0000 0111 1100 1000      -326 ：1111 1111 1111 1111 1111 1110 1011 1010 5、计算补码      1992 ：0000 0000 0000 0000 0000 0111 1100 1000      -326 ：1111 1111 1111 1111 1111 1110 1011 1010      结果  :  1 0000 0000 0000 0000 0000 0110 1000 0010 6、将数据转化为10进制 110 1000 0010 2+128+512+1024 = 1666 无符号： unsigned int a= 1986 无符号：1111 1111 1111 1111 1111 1111 1111 1111 =               0000 0000 0000 0000 0000 0000 0000 0000 =0 无符号整型取值：0-4294967295（2^32-1） 无符号的字符型：0-255 有符号：      int a= 1986      0111 1111 1111 1111 1111 1111 1111 1111 = 2147483647      0000 0000 0000 0000 0000 0000 0000 0001 原码： 1111 1111 1111 1111 1111 1111 1111 1111 = -2147483647 反码：1000 0000 0000 0000 0000 0000 0000 0000 补码：1000 0000 0000 0000 0000 0000 0000 0001=-2147483647 -0的补码 补码：1000 0000 0000 0000 0000 0000 0000 0000=-0 = -2147483648

转载于:https://www.cnblogs.com/WangGuiHandsome/p/9870298.html