C语言学习之路（基础篇）—— 数据类型 02

说明：该篇博客是博主一字一码编写的，实属不易，请尊重原创，谢谢大家！

整型：int

1) 整型变量的定义和输出

#include

int main() {

	int a = 123;	//定义变量a，以10进制方式赋值为123
	int b = 0567;	//定义变量b，以8进制方式赋值为0567
	int c = 0xabc;	//定义变量c，以16进制方式赋值为0xabc

	printf("a = %d\n", a);
	printf("8进制：b = %o\n", b);
	printf("10进制：b = %d\n", b);
	printf("16进制：c = %x\n", c);
	printf("16进制：c = %X\n", c);
	printf("10进制：c = %d\n", c);

	unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
	printf("有符号方式打印：d = %d\n", d);
	printf("无符号方式打印：d = %u\n", d);
	return 0;

输出结果：
a = 123
8进制：b = 567
10进制：b = 375
16进制：c = abc
16进制：c = ABC
10进制：c = 2748
有符号方式打印：d = -1
无符号方式打印：d = 4294967295
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2) 整型变量的输入

scanf()： 从键盘（标准输入）读取数据

示例1： 获取键盘输入 123，并输出

int main() {

	int num;
	printf("请输入num的值：");
	scanf("%d", &num);
	printf("num=%d\n", num);

	return 0;
}

运行结果：
请输入num的值：123
num=123
1
2
3
4
5
6
7
8
9
10
11
12
13

示例2： 键盘输入 1234 56，并输出

因为是 %d 输出，所以遇到除了0-9的数就结束获取，然后打印，所以结果为1234

示例3： 如何通过 scanf 方法一次性获取键盘输入的两个值 123 和 456，并输出

#define _CRT_SECURE_NO_WARNINGS
#include


int main() {

	int num;
	int sum;
	printf("请分别输入num和sum的值：");
	scanf("%d %d", &num, &sum);
	printf("num=%d\n", num);
	printf("sum=%d\n", sum);

	return 0;
}

运行结果：
请分别输入num和sum的值：123 456
num=123
sum=456
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

以上代码，如果只输入一个值 123456，那么就会出现等待用户输入第二个数来复制给变量 sum 的

示例4： scanf(“%d\n”, &num); 方法中不要加 “\n”

3) short、int、long、long long

补充：

• 严格来说，char 其实也是整数类型(integer type)，因为 char 类型储存的实际上是整数，而不是字符。计算机使用特定的整数编码来表示特定的字符。美国普遍使用的编码是 ASCII(American Standard Code for Information Interchange 美国信息交换标准编码)。例如：ASCII 使用 65 来代表大写字母 A，因此存储字母 A 实际上存储的是整数65。

注意：

• 需要注意的是，整型数据在内存中占的字节数与所选择的操作系统有关。虽然 C 语言标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型， short 类型整数的长度不能长于 int 类型。
• 当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。但当一个大的类型赋值给一个小的数据类型，那么就可能丢失高位。

示例：

#include 

int main()
{
	short a = 10;
	int b = 10;
	long c = 10l; //或者10L  但一般直接写10 就可以了， 不用在常量后面加l
	long long d = 10ll; //或者10LL

	printf("sizeof(a) = %u\n", sizeof(a));
	printf("sizeof(b) = %u\n", sizeof(b));
	printf("sizeof(c) = %u\n", sizeof(c));
	printf("sizeof(c) = %u\n", sizeof(d));

	printf("short a = %hd\n", a);
	printf("int b = %d\n", b);
	printf("long c = %ld\n", c);
	printf("long long d = %lld\n", d);

	unsigned short a2 = 20u; // 一般不用在常量后面加u
	unsigned int b2 = 20u;
	unsigned long c2 = 20ul;
	unsigned long long d2 = 20ull;

	printf("unsigned short a2 = %hu\n", a2);
	printf("unsigned int b2 = %u\n", b2);
	printf("unsigned long c2 = %lu\n", c2);
	printf("unsigned long long d2 = %llu\n", d2);

	return 0;

}

输出结果：
sizeof(a) = 2
sizeof(b) = 4
sizeof(c) = 4
sizeof(c) = 8
short a = 10
int b = 10
long c = 10
long long d = 10
unsigned short a2 = 20
unsigned int b2 = 20
unsigned long c2 = 20
unsigned long long d2 = 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

关键字：sizeof

• sizeof 不是函数，所以不需要包含任何头文件，它的功能是计算一个数据类型的大小，单位为字节
• sizeof 的返回值为 size_t
• size_t 类型在 32位 操作系统下是 unsigned int，是一个无符号的整数

#include


int main() {
	char a;
	short b;  // short int b; 此写法表示短整型 int 写不写无所谓
	int c;
	long d; // long int d; int 写不写无所谓
	long long e;
	// sizeof 用来测试数据类型的大小
	int len = sizeof(a);
	printf("%d\n", len);
	printf("%d\n", sizeof(b));
	printf("%d\n", sizeof(c));
	printf("%d\n", sizeof(d));
	printf("%d\n", sizeof(e));
	// 还可以直接如下打印出数据类型的大小
	printf("%d\n", sizeof(int));

	size_t r = sizeof(a);
	printf("r = %u\n", r);//用无符号数的方式输出c的值
	return 0;
}


输出结果：
1
2
4
4
8
4
r = 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

切换成 x64 位运行结果如下：

字符型：char

1) ASCII对照表

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

• ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
• ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。数字 127 代表 Del 命令。

2) 字符变量的定义和输出

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

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

通过ASCII表可以看出一共有127个ASCII码，一个ASCII码值对应一个字符，也就是说使用127个ASCII码就能表示所有的字符了，而 char 类型不管有无符号都能存的下127，那么说用 char 类型就可以存得下一个字符，所以 char 类型也叫字符类型。

示例：

#include


int main() {
	// 打印出字符a的的ASCII码
	char ch1 = 'a';
	char ch2 = 97;
	char ch3 = 'A';
	printf("%d\n", ch1);  // 打印出字符a的ASCII码：97
	// 打印出字符/n的ASCII码
	printf("%d\n", '\n');  // 10
	// 打印出ch2值（ASCII码）所对应的字符
	printf("%c\n", ch2); // a
	// 打印字符
	printf("%c\n", ch1); // a
	// 小写a转大写A
	ch1 = ch1 - 32;  //65
	printf("%c\n", ch1); // A
	//大写A转小写a
	ch3 = ch3 + 32;
	printf("%c\n", ch3); // a
	// 字符的大小
	printf("sizeof(ch) = %d\n", sizeof(ch1)); // sizeof(ch) = 1
	printf("sizeof('a') = %d\n", sizeof('a')); // sizeof('a') = 4 等同于 sizeof(97)
	// 字符转数字
	char ch4 = '8'; // 字符'0'的ASCII码为48,字符'8'的ASCII码为56
	int num = ch4 - '0'; // 即 56-48就等于数字8
	printf("num=%d\n", num); // // num=8
	//简化后则是 字符 - '0'即可将字符转为数字
	ch4 = ch4 - '0'; 
	printf("ch4=%d\n", ch4);// ch4=8
	// 空字符
	char ch5 = ' ';
	printf("ch5=%d\n", ch5);  //ch5=32 空字符的ASCII码为32
	// 通过 +、-空字符就可以完成字符字母大小写转换了
	printf("A = %c\n", 'a' - ' '); // A = A
	printf("a = %c\n", 'A' + ' '); // a = a

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3) 字符变量的输入

int main() {
	
	char ch = 0;
	char ch2 = 0;
	printf("请输入字符ch的值：");
	scanf("%c", &ch);
	printf("ch=%c\n", ch); // ch=a
	scanf("%c", &ch2);
	printf("ch2=%c\n", ch2); // ch2=
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

以上代码中 变量ch2 的值为 \n 回车，那么可以使用 %d 打印出 字符变量ch2 的 ASCII码 的值

可以通过在回车后再添加一个scanf函数来吃掉回车即可。

4) 转义字符

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

示例：

int main() {
	printf("abc\bdef"); // abdef
	printf("\n");
	printf("abc\ndef"); // abc
						// def
	printf("\n");
	printf("abc\rdef"); // def
	printf("\n");
	printf("abc\tdef"); // abc     def
	printf("\n");
	printf("abc\\def"); // abc\def
	printf("\n");
	printf("abc\"def"); // abc"def

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

实型(浮点型)：float、double

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

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

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

示例：

#include


int main() {

	// 不以f结尾的常量是double类型，以f结尾的常量(如3.14f)是float类型
	printf("%d\n", sizeof(3.14));  // double类型 8字节
	printf("%d\n", sizeof(3.14f)); // float类型  4字节


	float a = 3.14159265358979323846;
	double b = 3.14159265358979363846;

	// float 和 double 类型默认输出6位小数
	printf("a=%f\n", a);  // a=3.141593
	printf("b=%lf\n", b); // b=3.141593

	// float 和 double 打印8位小数
	printf("a=%.8f\n", a);  // a=3.14159274  
	printf("b=%.8lf\n", b); // b=3.14159265  

	// float类型能够保证的精度是7位有效数字 (第7位会根据第8位的值而被四舍五入，所以第7位有可能精确，也有可能不精确)
	// double类型能够保证的精度是15位有效数字 (第15位会根据第16位的值而被四舍五入，所以第15位有可能精确，也有可能不精确)
	printf("a=%.7f\n", a);  // a=3.14159274  
	printf("b=%.15lf\n", b); // b=3.14159265  

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

类型限定符

示例：

#include


int main() {
	//extern 关键字只做声明，不能做任何定义
	//声明一个int类型变量a，a在这里没有建立存储空间
	extern int a;
	//a = 10; //err, 没有空间，就不可以赋值
	
	// 定义一个int类型常量b
	const int b;
	// b = 5; // err, 常量的值不能修改

	// 防止编译器优化代码
	// 没有volatile修饰符，系统会去进行优化处理，如存储器映射的硬件寄存器，就需要每一次sum的值也就是i是多少
	// 就好比你跟四个人相亲，你跟媒婆说你要最帅的，但媒婆就只给你看了四人当中最帅的那个人，而其实你的本意是想这四个人你都要看一下，然后选出最帅的那个人。
	volatile int sum;
	for (int i = 0; i < 100; i++)
	{
		sum = i;
	}
	printf("sum=%d", sum);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

字符串格式化输出和输入

1) 字符串格式化输出和输入

• 字符串是内存中一段连续的char空间，以’\0’(数字0)结尾。
• 字符串常量是由双引号括起来的字符序列，如"cdtaogang"、“C program”，"$38.8"等都是合法的字符串常量。

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

每个字符串的结尾，编译器会自动的添加一个结束标志位’\0’，即 “a” 包含两个字符’a’和’\0’，\0 的ASCII码为 0


数字 0——>内存中存的是 0
字符 ‘0’——>内存中存的是 48
字符 ‘\0’——>内存中存的是 0
即 ‘\0’ == 0

#include

int main() {
	// 打印字符串
	printf("%s", "CSDN:cdtaogang");

	return 0;
}
1
2
3
4
5
6
7
8

2) printf函数和putchar函数

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

#include

int main() {
	// 打印字符串
	printf("%s\n", "CSDN:cdtaogang"); // CSDN:cdtaogang
	// 使用putchar输出字符
	char ch = 'a';
	printf("%c\n", ch); // a
	putchar(ch); // a
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

printf格式字符：

printf附加格式：

示例：

#include 


int main()
{
	int a = 100;
	printf("a = %d\n", a); // 格式化输出一个字符串 a = 100
	printf("%p\n", &a); // 输出变量a在内存中的地址编号 0039FBF4
	printf("%%d\n"); // 输出一个百分号 %d

	char c = 'a';
	putchar(c);//putchar只有一个参数，就是要输出的char  a
	long a2 = 100;
	printf("%ld, %lx, %lo\n", a2, a2, a2); // 100, 64, 144

	long long a3 = 1000;
	printf("%lld, %llx, %llo\n", a3, a3, a3); // 1000, 3e8, 1750

	int abc = 10;
	printf("abc = '%6d'\n", abc); // abc = '    10'  宽度占6位
	printf("abc = '%-6d'\n", abc); // abc = '10    '  左对齐，宽度占6位
	printf("abc = '%06d'\n", abc); // abc = '000010'  宽度占6位，不足位数用0补齐
	printf("abc = '%-06d'\n", abc); // abc = '10    '  // 左对齐和补0不能同时用 （改变了数的大小了），但是程序没进行补0操作

	double d = 12.3;
	printf("d = \' %-10.3lf \'\n", d); // d = ' 12.300     '
	// m.n    m指的是宽度   n指的是小数点的位数
	printf("d=%10.2lf\n", d); // d=     12.30

	double e = 1234.56;
	printf("e=%lf\n", e); // e = 1234.560000
	printf("e=%e\n", e); // e=1.234560e+03
	printf("e=%E\n", e); //	e=1.234560E+03

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

3) scanf函数与getchar函数

• getchar是从标准输入设备读取一个char。
• scanf通过%转义的方式可以得到用户通过标准输入设备输入的数据。
• 作用：两个函数都是从键盘读取一个字符。

示例：

int main() {
	
	char ch;
	// 使用scanf函数获取键盘输入的字符
	//scanf("%c", &ch);
	// 使用getchar函数获取键盘输入的字符
	ch = getchar();
	printf("ch=%c\n", ch); // ch=a
	ch = getchar();
	printf("ch=%c\n", ch); // ch=   跟scanf函数一样，第二次获取了\n 回车

	// 获取键盘输入a\n 和 b\n
	ch = getchar();
	printf("ch=%c\n", ch); // ch=a
	getchar(); // 为了获取多个键盘输入，那么方式跟scanf函数一样，在中间添加getchar函数来吃点 \n 回车
	ch = getchar();
	printf("ch=%c\n", ch); // ch=b
	  
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20