[C]基础2.常见概念(下)

• 博客主页：算法歌者
• 本篇专栏：[C]
• 您的支持，是我的创作动力。

---

---

0、总结

1、数据类型

1、类型

数据类型：用来描述生活中的各种数据。

例如，整数类型描述整数，字符类型描述字符、浮点型类型描述小数等等。因此，类型是相似的数据拥有的共同特征。

编译器需要先知道数据的类型，才懂得怎么操作数据。

C语言的类型归纳总结，如下：

布尔类型的运用：

#include <stdio.h>
#include <stdbool.h>
int main()
{
	_Bool flag = true;
	if (flag)
		printf("hehe\n");
	return 0;
}

输出：
hehe

2、长度

sizeof操作符：用来计算操作数的类型长度，单位是字节。

sizeof操作数可以是类型，也可以是变量或者表达式。

sizeof(类型)
// 操作数如果是表达式，可以省略掉后面的括号。
// 表达式不参与运算，是根据表达式的类型得出大小。
sizeof 表达式

数据类型的长度：

#include <stdio.h>
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;
}

输出：
1
2
4
4
8
4
8
8

操作数为表达式：

#include <stdio.h>
int main()
{
	short s = 4;
	int a = 10;
	printf("%zd\n", sizeof(s));
	printf("%zd\n", sizeof(a));
	printf("%zd\n", sizeof(s = a + 5));
	return 0;
}

输出：
2
4
2

浅谈一下为什么size_t 占位符是%zd？

size_t类型：意思是无符号的整型。
sizeof操作符返回值的类型由系统决定，返回类型可能是unsigned int、也可能是unsigned long等等。printf()对应占位符分别是%u、%lu等等。类型的不确定，是不利于程序的可移植。

为了解决这个问题，创造类型的别名size_t，进行统一表示sizeof的返回值类型。size_t对应当前系统的sizeof的返回值类型，可能是unsigned int、也可能是unsigned long等等。printf()对应占位符是%zd，类型的确定，利于程序的可移植。

3、取值范围

每一种数据类型有自己的取值范围，也就是存储的数值的最小值和最大值的区间。

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的最大值

4、signed 和unsigned

signed关键字：一个类型带有正负号。

unsigned关键字：该类型不带有正负号，只能表示零和正整数。

signed和unsigned关键字修饰字符型和整型类型。

#include <stdio.h>
int main()
{
	signed int a;
	// 等同于int a;
	return 0;
}

占位符的%d和%u：

#include <stdio.h>
int main()
{
	// %d - 打印有符号整数
	// %u - 打印无符号整数
	signed int a = 10;
	printf("%u\n", a);
	printf("%d\n", a);
	a = -20;
	printf("%u\n", a);
	printf("%d\n", a);
	a = 0;
	printf("%u\n", a);
	printf("%d\n", a);
	return 0;
}

输出：
10
10
4294967276
-20
0
0

在整型，默认情况下：

• signed int == int
• signed short == short
• signed long == long
• signed long long == long long

但在字符型，char是signed char，还是unsigned char，取决于编译器。

5、强制类型转换

强制类型转换的语法形式：

(类型)

代码：

#include <stdio.h>
int main()
{
	int a = (int)3.14;
	printf("%d\n", a);
	return 0;
}

输出：
3

2、变量

变量有全局变量和局部变量，区别是使用范围，局部变量的使用范围比较局限。

全局变量：在大括号外部定义的变量。

局部变量：在大括号内部定义的变量。

#include <stdio.h>
int global = 2024; // 全局变量
int main()
{
	int local = 2023; // 局部变量
	printf("%d\n", local);
	printf("%d\n", global);
	return 0;
}

输出：
2023
2024

全局变量和局部变量的初始化：

#include <stdio.h>
// 全局变量不初始化，默认是0。
// 局部变量不初始化，默认是随机值。
int global;
int main()
{
	printf("%d\n", global);
	return 0;
}

输出：
0

当全局变量和局部变量同名时，局部变量优先使用：

#include <stdio.h>
int a = 100;
int main()
{
	int a = 10;
	printf("%d\n", 10);
	return 0;
}

输出：
10

全局变量和局部变量在内存中存储：

在学习C语言和C++语言时候，会关注内存中的三个区域：栈区、堆区、静态区。

• 局部变量放在内存的栈区。
• 全局变量放在内存的静态区。
• 堆区用来动态内存管理。

3、操作符

1、算术操作符

算术操作符：用来运算，+、-、*、/、%，这些操作符都是双目操作符。

操作符也叫做运算符。

#include <stdio.h>
int main()
{
	int x = 1 + 2;
	int y = 2 - 1;
	int z = 2 * 3;
	printf("%d\n", x);
	printf("%d\n", y);
	printf("%d\n", z);
	return 0;
}

输出：
3
1
6

浮点数运算，想得到浮点数，两个运算数必须至少有一个浮点数：

#include <stdio.h>
int main()
{
	float a = 6 / 4;
	int b = 6 / 4;
	// 整数除法是整除，只返回整数部分，丢弃小数部分。
	printf("%f\n", a);
	printf("%d\n", b);
	printf("------\n");
	// 如果想得到浮点数，两个运算数必须至少有一个浮点数。
	float c = 6.0 / 4;
	printf("%f\n", c);
	return 0;
}

输出：
1.000000
1
------
1.500000

求模运算，运算符只能用于整数，不能用于浮点数。

#include <stdio.h>
int main()
{
	int x = 6 % 4;
	printf("%d\n", x);
	return 0;
}

输出：
2

负数求模的规则：结果的正负号由第一个运算数的正负号决定。

#include <stdio.h>
int main()
{
	printf("%d\n", 11 % 5);
	printf("%d\n", 11 % -5);
	printf("%d\n", -11 % 5);
	printf("%d\n", -11 % -5);
	return 0;
}

输出：
1
1
-1
-1

2、赋值操作符

初始化：在变量创建的时候，给一个初始值。

赋值：在变量创建好后，再给一个值。

#include <stdio.h>
int main()
{
	int a = 100; // 初始化
	a = 200; // 赋值
	return 0;
}

连续赋值：

#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = 0;
	// 连续赋值，从右向左依次赋值的。
	c = b = a + 3;
	printf("%d\n", c);
	return 0;
}

输出：
6

复合赋值符：

#include <stdio.h>
int main()
{
	int a = 10;
	a += 3;
	printf("%d\n", a);
	a -= 2;
	printf("%d\n", a);
	// 复合赋值符:
	// 1、+=  -=
	// 2、*=  /=  %=
	// 3、>>=  <<=
	// 4、&=  |=  ^=
	return 0;
}

输出：
13
11

3、单⽬操作符

单目操作符：只有一个操作数。

++、--、+（正）、-（负）都是单目操作符。

++是一种自增的操作符，分前置++和后置++，--是一种自减的操作符，也分前置–和后置–。

#include <stdio.h>
int main()
{
	int a = 10;
	// 前置++，先+1，后使用。
	// 等同于：
	// a = a + 1;
	// b = a;
	int b = ++a;
	printf("a = %d, b = %d\n", a, b);

	// 后置++，先使用，后+1
	// 等同于：
	// d = c;
	// c = c + 1;
	int c = 10;
	int d = c++;
	printf("c = %d, d = %d\n", c, d);
	return 0;
}

输出：
a = 11, b = 11
c = 11, d = 10

#include <stdio.h>
int main()
{
	int a = 10;
	printf("%d\n", a++);
	printf("%d\n", a);

	int b = 10;
	printf("%d\n", ++b);
	printf("%d\n", b);
	return 0;
}

输出：
10
11
11
11

4、scanf和printf

1、printf()的占位符

占位符：这个位置可以用其他值代入。

printf()的常用占位符：

printf()的常用占位符	含义
%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类型
%%	输出一个百分号

2、printf()

printf()：将参数文本输出到屏幕。它名字里面的f代表format（格式化），表示可以定制输出文本的格式。

printf()允许限定占位符的最小宽度。

#include <stdio.h>
int main()
{
	// 输出为"  123"
	// 默认右对齐。
	printf("%5d\n", 123);
	// 左对齐
	printf("%-5d\n", 123);
	return 0;
}

输出：
  123
123

上面示例中，%5d表示这个占位符的宽度至少5位，输出的值默认是右对齐。如果改为左对齐，在占位符的%的后面插入一个-号。

%+d可以确保输出的数值，总是显示正负号：

#include <stdio.h>
int main()
{
	printf("%+d\n", 12);
	printf("%+d\n", -12);
	return 0;
}

输出：
+12
-12

输出小数时，有时希望限定小数的位数，比如只保留两位，占位符可以写成%.2f。

还可以与限定宽度占位符，结合使用，例如%6.2f表示最小宽度为6，小数位数为2。

#include <stdio.h>
int main()
{
	printf("%.2f\n", 0.5);
	printf("%6.2f\n", 0.5);
	return 0;
}

输出：
0.50
  0.50

最小宽度和小数位数这两个限定值，都可以用*代替。如下：

#include <stdio.h>
int main()
{
	// 等效于%6.2f
	printf("%*.*f\n", 6, 2, 0.5);
	return 0;
}

输出：
  0.50

%s占位符默认全部输出字符串，如果只想输出开头部分，可以用%.[m]s指定输出的长度。其中[m]代表一个数字，表示要输出的长度。如下：

#include <stdio.h>
int main()
{
	printf("%.4s\n", "hello world");
	return 0;
}

输出：
hell

3、printf()的返回值

printf()的返回值：如果成功，则返回写入的字符总数，否则返回一个负数。

如下：

#include <stdio.h>
int main()
{
	int a = 0;
	a = printf("%s", "hello world");
	printf("\n");
	printf("%d\n", a);
    
	printf("------\n");
    
	int b = 0;
	b = printf("%d", 12345);
	printf("\n");
	printf("%d\n", b);
	return 0;
}

输出：
hello world
11
------
12345
5

来自阿里的一个面试题：

#include <stdio.h>
int main()
{
	printf("%d\n", printf("%d\n", printf("hello!\n")));
	return 0;
}

输出：
hello!
7
2

4、scanf()的占位符

scanf()的常用占位符：

scanf()的常用占位符：	含义
%c	字符
%d	整数
%f	float类型浮点数
%lf	double类型浮点数
%Lf	long double类型浮点数
%s	字符串
%[]	在方括号中指定一组匹配的字符（比如%[0-9]），遇到不在集合之中的字符，匹配将会停止

5、scanf()

scanf()：读取用户的键盘的输入。

用户输入数据、按下回车键后，scanf()就会处理用户的输入，将其存入变量。

它的第一个参数是一个格式字符串，告诉编译器需要提取数据是什么类型。其余的参数是存放用户输入的变量。

#include <stdio.h>
int main()
{
	int score = 0;
	printf("请输入成绩：");
	scanf("%d", &score);
	printf("成绩是：%d\n", score);
	return 0;
}

输入：
30
输出：
请输入成绩：30
成绩是：30

浅谈一下scanf()函数为什么需要取地址符&？

用scanf()函数输入时，要在函数内对变量值进行修改。而printf()函数输出时，只用到变量的值，不需要再函数内改变变量的值。

原理：如果普通的函数参数传递，比如传递a，变量接收的方式是在函数内另建一个变量b，把a的值传递给b即可，即使对b的值进行修改，也不影响变量a。如果传地址，比如把a的地址p1传递给函数里的指针变量p2，p2接收a的地址p1，这时p2指向a。对p2指向的a进行修改，就能对变量a修改。

当然，如果scanf()函数里的变量是指针变量或者字符串变量，就不需要加&运算符。

小拓展：scanf()函数是C语言标准库中的函数。而scanf_s()是VS的函数，其他编译器不认识这个函数，为了可移植性，用scanf()函数。在VS使用scanf()函数，需要在源文件的第一行添加#define _CRT_SECURE_NO_WARNINGS 1即可。如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int score = 0;
	printf("请输入成绩：");
	scanf("%d", &score);
	printf("成绩是：%d\n", score);
	return 0;
}

输入：
30
输出：
请输入成绩：30
成绩是：30

想在VS上新建源文件都有#define _CRT_SECURE_NO_WARNINGS 1，需要在newc++file.cpp的文件加上这句话：#define _CRT_SECURE_NO_WARNINGS 1。

值得一提是，scanf()处理数值占位符，会自动过滤空白字符，包括空格、制表符、换行符等。

#include <stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	double c = 0.0;
	double d = 0.0;
	printf("请输入四个值：\n");
	scanf("%d%d%lf%lf", &a, &b, &c, &d);
	printf("输出的结果：\n");
	printf("%d\n%d\n%f\n%f\n", a, b, c, d);
	return 0;
}

输入：
1 2 3 4
输出：
请输入四个值：
1 2 3 4
输出的结果：
1
2
3.000000
4.000000

每次按下回车键，scanf()开始解读，第一行匹配第一个占位符，下次按下回车键，就从第二个占位符开始解读。

原理是：用户的输入先放入缓存，等到按下回车键，按照占位符对缓存进行解读。解读用户的输入时，会从上一次解读遗留的第一个字符开始，直到读完缓存，或者遇到第一个不符合条件的字符为止。

在下面的示例，scanf()读取用户的输入，%d占位符会忽略起首的空格，从-处开始获取数据，读到-13停下来，因为-13后面的.不属于整数的有效字符，所以占位符%d读到-13。第二次调用scanf()时，就从上一次停止解读的地方，继续往下读取，这一次读取的首字符是.，因为对应的占位符是%f，会读取到.45e12，这是采用科学计数法的浮点数格式。后面的#不属于浮点数的有效字符，所以会停在这里。

#include <stdio.h>
int main()
{
	int x;
	float y;
	// 用户输入"   -13.45e12# 0"
	scanf("%d", &x);
	printf("%d\n", x);
	scanf("%f", &y);
	printf("%f\n", y);
	return 0;
}

输入：
   -13.45e12# 0
输出：
-13
449999994880.000000

上面所用占位符之中，除了%c之外，都会自动忽略起首的空白字符。%c不忽略空白字符，总是返回当前第一个字符，无论该字符是否为空格。如果要强制掉过字符前的空白字符，可以写成scanf(" %c", &ch)，即%c前加上一个空格，表示跳过零个或多个空白字符。

对于占位符%s，规则是从当前第一个非空白字符开始读起，直到遇到空白字符（空格、换行符、制表符等）为止。因此scanf()不适合读取可能包含空格的字符串。另外，scanf()遇到%s占位符，会在字符串变量末尾存储一个空字符\0。

scanf()将字符读入字符数组时，不会检测字符串是否超过数组长度。为了防止这种情况，使用%s占位符，指定读入字符串的最长长度，即写成%[m]s，其中的[m]是一个整数，表示读取字符串的最大长度，后面的字符将被丢弃。

#include <stdio.h>
int main()
{
	char name[11];
	// 输入"hellonihaoworld"
	scanf("%10s", name);
	printf("%s\n", name);
	printf("%.5s\n", name);
	return 0;
}

输入：
hellonihaoworld
输出：
hellonihao
hello

上面的示例，没有数组溢出的风险。

有时，用户的输入可能不符合预定的格式，为了避免这种情况，scanf()提供了一个赋值忽略符*，只要把*加在任何占位符的百分号后面，该占位符就不会返回值，解析后将被丢弃。如下：

#include <stdio.h>
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;
}

输入：
2024 06 01
输出：
2024-6-1

上面的示例，%*c表示这个占位符没有对应的变量，解读后不必返回。

6、scanf()的返回值

scanf()的返回值：是一个整数，表示成功读取的变量个数。

如果没有读取任何项，或者匹配失败，则返回0，如果在成功读取任何数据之前，发生了读取错误或者遇到读取到文件结尾，则返回常量EOF。

如下：

#include <stdio.h>
int main()
{
	int a = 0, b = 0;
	while (scanf("%d %d", &a, &b) != EOF)
	{
		int c = a + b;
		printf("%d\n", c);
	}
	return 0;
}

输入：
1 2
1 3
1 4
输出：
3
4
5

上面的示例，可以进行多组测试。

---

完。