Joyan

公告

记录平时自己学习的内容

标签

Joyan

公告

记录平时自己学习的内容

Learn More

标签

ACID ARP Astro Bash C C 语言 C/S 架构 CIDR CRUD DDL DNS dup ext2 GCC GDB IM 聊天系统 IM 聊天系统阶段 inode IPv4 Linux Linux 命令 Linux 工具与文件系统阶段 lseek Make Makefile Mizuki MySQL Nagle open Qt QUIC read Shell Socket SQL TCP UDP VFS Vim Windows Winsock write 三次握手中介者模式事务信号与槽内存管理内存管理阶段分段分页协议设计博客四次挥手在线状态地址转换基础语法增量编译多态多线程多表联查好友列表子网划分字符编码存储过程学习笔记学习索引学习路线开发工具心跳机制成员函数指针拥塞控制指针操作系统数据库数据库范式数据库阶段数据查询数据结构文件 I/O 文件描述符文件操作文件权限文件系统注册与登录流程控制流量控制添加好友滑动窗口环境变量用户下线用户管理目录操作目录结构硬链接视图程序设计符号链接粘包系统调用编译缺页中断网络基础阶段网络管理网络编程聊天功能自动化构建自定义函数虚拟内存触发器计算机网络设计模式调试路由软件包管理进程管理阻塞与非阻塞非阻塞 I/O 页面置换项目总结

Joyan

公告

记录平时自己学习的内容

Learn More

标签

ACID ARP Astro Bash C C 语言 C/S 架构 CIDR CRUD DDL DNS dup ext2 GCC GDB IM 聊天系统 IM 聊天系统阶段 inode IPv4 Linux Linux 命令 Linux 工具与文件系统阶段 lseek Make Makefile Mizuki MySQL Nagle open Qt QUIC read Shell Socket SQL TCP UDP VFS Vim Windows Winsock write 三次握手中介者模式事务信号与槽内存管理内存管理阶段分段分页协议设计博客四次挥手在线状态地址转换基础语法增量编译多态多线程多表联查好友列表子网划分字符编码存储过程学习笔记学习索引学习路线开发工具心跳机制成员函数指针拥塞控制指针操作系统数据库数据库范式数据库阶段数据查询数据结构文件 I/O 文件描述符文件操作文件权限文件系统注册与登录流程控制流量控制添加好友滑动窗口环境变量用户下线用户管理目录操作目录结构硬链接视图程序设计符号链接粘包系统调用编译缺页中断网络基础阶段网络管理网络编程聊天功能自动化构建自定义函数虚拟内存触发器计算机网络设计模式调试路由软件包管理进程管理阻塞与非阻塞非阻塞 I/O 页面置换项目总结

6723 字

90 分钟

C 语言学习笔记：从基础语法到文件操作

2026-07-15

C 语言

C

/

C 语言

/

程序设计

/

基础语法

/

指针

/

数据结构

/

学习笔记

C 语言学习笔记：从基础语法到文件操作#

这篇笔记系统整理 C 语言从入门到常用数据结构与文件操作的核心知识，涵盖基础语法、输入输出、流程控制、指针、数组、函数、内存管理、字符串、结构体、链表等内容。

文中的部分示例以 Windows 和 Visual Studio 开发环境为基础；涉及平台相关的头文件、函数和数据类型大小时，应以实际编译器与目标架构为准。

C 与 C++ 的区别#

C 语言以面向过程的程序设计为主，侧重具体功能和算法的实现，常用“数据结构 + 算法 = 程序”来概括其核心思路。

C++ 在兼容大部分 C 语言语法的基础上，引入了面向对象、泛型编程等机制，更侧重程序架构与抽象设计，适合构建规模更大、结构更复杂的软件项目。

常用配置与函数#

关闭安全提示#

1
#define _CRT_SECURE_NO_WARNINGS

数学函数#

1
#include <math.h>
2
pow(n,3);//n的3次方
3
sqrt(25);//25的平方根
4
fabs(-3);//绝对值
5
ceil(2.001);//向上取整，结果为3
6
floor(2.999);//向下取整，结果为2

随机数#

1
#include<stdio.h>
2
#include<stdlib.h>
3
int main()
4
{
5
  int n = rand();
6
  printf("%d\n", n);
7
  return 0;
8
}

通过这种方式可以获取随机数，但是多试几次就会发现，总是生成一个相同的数字，所以这是个伪随机数

可以通过在生成随机数之前设置种子数来让随机数变得随机，不再是那个相同的数

1
srand(21);

但是，设置完后发现，数是变了，但是还是生成重复的相同的数，所以我们要让种子数通过时间来永恒变化

1
#include<stdio.h>
2
#include<stdlib.h>
3
#include<time.h>
4
int main()
5
{
6
  time_t t;
7
  t = time(NULL);
8
  printf("%lld\n", t);//这个数字是1970年至今的秒数
9
  srand(t);
10
  int n = rand();
11
  printf("%d\n", n);
12
  return 0;
13
}

假设你要从1-31里随机一个数的话，你需要

1
printf("%d", rand() % 31 + 1);

清空键盘缓冲区#

1
setvbuf(stdin, NULL, 0, 100);

入门与开发环境#

基本程序框架#

1
#include <stdio.h>
2
int main1()
3
{
4
  printf("hello world\n\n\n");
5

6

7
  return 0;
8
}

main函数的唯一性#

main函数或称主函数是C语言开发的软件项目必须有的一个入口模块

注意：main函数不能重复定义，所以此处代表本程序有另一个执行入口main，所以此处使用main1

快捷键#

开始执行（不调试）#

ctrl+F5

替换#

ctrl+h

调取提示#

ctrl+j

转到定义#

ctrl+左键

printf 格式化输出#

1
#include<stdio.h>
2
int main()
3
{
4
    //printf(3 + 5);错！
5
  printf("12345679 * 9 = %d \n", 12345679 * 9);
6
  printf("12345679 * 18 = %d \n", 12345679 * 18);
7

8
  return 0;
9
}

格式占位符的写法#

类似%d的用法

（ [] 代表可选项）

书写标准：%[补充位标志] [数据文字的宽度] [能四舍五入的小数后位数例如：<.2>] [length] 数字类型符号

1
#include<stdio.h>
2
int main()
3
{
4
  printf("北京时间：%d:%i", 11, 8);//代表d和i均能代表整数
5
  printf("北京时间：%02d:%02i", 11, 8);//0代表不足位数时补0，2代表数据文字的宽度
6

7
  return 0;
8
}

注意：数据文字宽度仅限制不足该数时，用前面的补充位标志补齐，超过所设定的数据文字宽度也可以，不报错

1
//示例
2
#include<stdio.h>
3
int main()
4
{
5
  printf("%7d*%-7.1f=%.1f\n", 3, 0.7, 3 * 0.7);
6
  printf("%7.1f*%-7.1f=%.2f\n", 3.3, 6.7, 3.3 * 6.7);
7
  printf("%7.2f*%-7.1f=%.3f\n",3.33,66.7,3.33*66.7);
8
  printf("%7.3f*%-7.1f=%.4f\n",3.333,666.7,3.333*666.7);
9
  printf("%7.4f*%-7.1f=%.5f\n",3.3333,6666.7,3.3333*6666.7);
10
  printf("%7.5f*%-7.1f=%.6f\n", 3.33333, 66666.7, 3.33333 * 66666.7);
11

12

13
  return 0;
14
}

%f默认打印六位小数

补充位标志中减号“-”代表左对齐

基本数据类型#

数据类型分为：基本类型（int float double char）指针类型、扩展类型（数组、enum、struct、union）

char占一字节，short占两字节，int占四字节，long占四字节，longlong占八字节（有无符号型整数所占字节相同）

单精度float小数点后7位，占四字节，双精度double小数点后15位，占八字节

1
#define _CRT_SECURE_NO_WARNINGS
2
#include<stdio.h>
3
int main()
4
{
5
  int n = 9;
6
  printf("signed int 字节数 %d %d %d\n", sizeof(int), sizeof(n), sizeof(9));
7
  unsigned int m = 9U;
8
  printf("unsigned int 字节数 %d %d %d\n", sizeof(unsigned int), sizeof(m), sizeof(9U));
9
  long p = 9L;
10
  printf("signed long int 字节数 %d %d %d\n", sizeof(long), sizeof(p), sizeof(9L));
11
  unsigned long q = 9UL;
12
  printf("unsigned long int 字节数 %d %d %d\n", sizeof(long), sizeof(q), sizeof(9UL));
13
  long long r = 9LL;
14
  printf("signed long long int 字节数 %d %d %d\n", sizeof(long long), sizeof(r), sizeof(9LL));
15
  unsigned long long s = 9ULL;
16
  printf("unsigned long long int 字节数 %d %d %d\n", sizeof(unsigned long long), sizeof(s), sizeof(9ULL));
17
  short t = 9;//没有后缀
18
  printf("signed short int 字节数 %d %d %d\n", sizeof(short), sizeof(s), sizeof(9));
19
  unsigned short u = 9u;
20
  printf("unsigned short int 字节数 %d %d %d\n", sizeof(unsigned short), sizeof(u), sizeof(9u));
21
  char v = 'A';
22
  printf("signed char 字节数 %d %d %d\n", sizeof(signed char), sizeof(v), sizeof('A'));
23
  unsigned char w = 48u;
24
  printf("unsigned signed char 字节数 %d %d\n", sizeof(unsigned char), sizeof(w));
25
  return 0;
26
}

注意：sizeof是个运算符，并不是函数，能够计算出表达式或数据类型在当前系统编译器下所占的内存字节数

命名要求的语法规则：只能包含字母、数字、下划线、美元符号，其中数字不能作为首字母，且不能使用编程语言的保留字（专有名词）

命名要求的开发规范：小驼峰、大驼峰（例如西安，小驼峰xiAn，大驼峰XiAn）

计算机存储基本概念#

字节是最小的存储单位，1Byte（字节）=8bit（比特，位）

1024B=1KB，1024KB=1MB，GB、TB、PB也依次按照1024换算

进制#

十进制转二进制：整数除2取余，小数乘2取整

其他进制打印方法

1
//没有直接打印二进制的方式
2
printf("八进制：%o\n",185);
3
printf("十六进制：%x\n",185);

C语言中，二进制以0B开头，八进制以0开头，十六进制以0X开头

内存存储原理：原码、反码、补码#

第一位均表示符号，正数都一样，负数反码全取反，补码取反+1

1
char aa = -16;
2
char bb = -5;
3
char cc = aa + bb;
4
printf("%d %u\n", cc, cc);//-21 4294967275
5
printf("%hhd %hhu\n", cc, cc);//-21 235

%d代表四个字节长度的有符号十进制，%u代表四个字节长度的无符号

hh代表char，即将正常的四个字节长度改为一字节长度

例子中，-21的补码为11101011，有符号的都正常显示了-21，而无符号的一字节长度将符号位的1视为数值，计算出十进制数值为235

而无符号的四字节长度，本身-21作为char只占一字节，打印时补齐了前三个字节，即都补11111111，计算出得4294967275

例题#

1
char m = -1;
2
unsigned char n = -1;
3
printf("%hhd %hhd", m / 2, n / 2);//0 127

解释

-1在这里其实是作为整型存在的，即四字节

也就是说两个char类型因为是一字节的，其实是读取了四字节的-1的最后一个字节，那么char读取的是-1，unsigned char读取的是255

分别对其/2，也就是0 127

由此得出不能光看数值，要看存储的方式和类型

1
unsigned short n = -1;
2
printf("%hu %hd %hd\n", n, n / 2, n / 2 + 1);

通过这样的方式可以看出short的三个边界值

所以，例如short a=32767，a++之后，a的值为-32768，并不是32768，我们把整数增加反而变小的现象称为溢出现象

当然，也可以利用limits.h头文件中定义好的最大值和最小值获取边界值

1
#include<stdio.h>
2
#include<limits.h>
3
int main()
4
{
5
  printf("char 最大值：%hhd 最小值：%hhd\n", CHAR_MAX, CHAR_MIN);
6
  printf("unsigned char 最大值：%hhu 最小值：%hhu\n", 0, UCHAR_MAX);
7
  //一些特殊的写法：SHRT_MAX LLONG_MAX
8

9
  return 0;
10
}

浮点#

定点存储（整型、字符型）使用的是符号位+原码、反码、补码，而浮点存储使用的是符号位+指数区+尾数区

浮点数的乘除法#

1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
int main()
4
{
5
  double r;
6
  double PI = 3.14;
7
  printf("输入球体半径\n");
8
  scanf("%lf", &r);
9
  double v = 4. / 3 * PI * r * r * r ;
10
  double s = 4 * PI * r * r;
11
  printf("该球体的体积为%.2f，表面积为%.2f\n",v,s);
12

13
  return 0;
14
}

这部分使用了4.来实现调用浮点数除法

浮点数的打印#

1
#include<stdio.h>
2
int main()
3
{
4
  float f = .25f;
5
  double d = .25;
6
  long double ld = .25l;
7
  printf("字节数：%d %d %d\n",sizeof(float),sizeof(double),sizeof(long double));
8
  float pi = 3.1415926f;
9
  double pi2 = 3.1415926;
10
  float dis = 1.08e9f;
11
  printf("小数形式：%f %f\n", pi, dis);
12
  printf("指数形式：%e %e\n", pi, dis);
13
  printf("最短形式：%g %g\n", pi, dis);
14
  return 0;
15
}

以上呈现的是浮点数多种打印方式，最推荐%g

类型转换#

1
//自动类型转换
2
printf("%d\n", sizeof(9u + 8ull + 0176 - 1578));//8
3
printf("%d\n", sizeof(9u + 8ull + 0176 - 1578.f));//4，float等级在这里是最高的，所以按照float的字节数输出
4
printf("%d\n", sizeof(9u + 8ull + 0176 - 1578.f+0.));//8，double的等级最高，输出double的字节数，而不是longlong的
5
//强制类型转换
6
printf("%d\n", sizeof(9u + (int)8ull + 0176 - (char)1578.f));//4，int的等级最高

字符型#

字符型存储不是字符的影像，而是字符影像的字符编码

单字节编码通常指ASCII码，双字节编码一般指unicode码

char与wchar区别是单字节（ASCII）和双字节（unicode，支持汉字）

1
wchar_t hanzi = L'姬';//L是双字节字符的前缀，=0x59ec

1
#include<stdio.h>
2
int main()
3
{
4
  printf("影像方式显示：%c\n", 0b01010110);//ASCII码 十进制对应86
5
  char ch1 = 'A';
6
  char ch2 = 65;
7
  char ch3 = '\101';//0113 八进制设置
8
  char ch4 = '\x41';//0x55 十六进制设置
9
  printf("%c %c %c %c", ch1, ch2, ch3, ch4);
10
  return 0;
11

12
}

1
printf("1234\b\b567\b890\n");//1256890

\b：退格，并不是删除而是退回之后再有输入的覆盖之前的

1
printf("12345678\r90\n");//90345678

\r：回到行首，之后类似于退格覆盖之前输入的东西，但是换行的\n是在最后换行的

1
printf("子曰：\"学而时习之，不亦说乎。\"\n");//子曰："学而时习之，不亦说乎。"
2
printf("100%%\n");//100%

被源代码、printf所征用的字符，用特殊的方式才能输出

scanf 格式化输入#

1
#define _CRT_SECURE_NO_WARNINGS //关闭安全警告，放在第一句
2
#include<stdio.h>
3
int main()
4
{
5
  int a = 1, b = 2, c = 3;
6
  scanf("%d%d%d", &a, &b, &c);
7
  printf("%d %d %d\n", a, b, c);
8

9
  return 0;
10
}

注意：连续输入中间不空格，不写换行符，写取地址符

从 Visual Studio 2005 开始，Microsoft 在 C 运行时库中引入了”安全开发生命周期”，将 scanf 等函数标记为”可能不安全”，并给出警告 C4996：提供了替代方案scanf_s

1
char x, y;
2
scanf_s("%c%c", &x, 1, &y, 1);//通过显式指定缓冲区大小，防止输入超过缓冲区容量

浮点数的 scanf#

1
double m = 0;
2
float n = 0;
3
scanf("%lf", &m);
4
scanf("%f", &n);
5
printf("m=%.2f  n=%.2f\n", m, n);

对于double类型的浮点数输入，需要在f前写一个小写L

工作原理#

按照格式扫描，空格和换行都是默认合法的间隔，遇到第一个非法格式字符就停止读取

如果将scanf改成

1
scanf("%d,%d,%d", &a, &b, &c);

在上面这个例子中强制使用逗号为合法间隔，此时空格和换行就是非法间隔不适用了

如果改成

1
scanf("a=%d,b=%d,c=%d", &a, &b, &c);

这样就必须严格按照a=%d,b=%d,c=%d的格式输入，其他格式的输入不会被识别

scanf 的返回值#

1
int r;
2
r = scanf("a=%d,b=%d,c=%d", &a, &b, &c);
3
printf("成功读取%d个变量\n",r);

按上述所示，如果a部分按照格式输入数字，之后不按照格式输入，r的值就等于1

源代码执行原理#

源代码到exe经过的几个时期

预处理期，在这一阶段，源码中的所有预处理语句得到处理，#include语句所包含的文件内容替换掉语句本身，所有已定义的宏被展开

编译期，编译器对源码进行词法分析、语法分析、优化等操作，最后生成汇编代码

汇编期：生成机器语言代码，保存在后缀为.o的目标文件中

连接期，把用到的库函数和你自己编写的这些机器指令或者目标文件汇总形成一个整体，这个整体就叫可执行文件

执行期，执行exe可执行文件

流程结构#

if（二选一）#

1
#define _CRT_SECURE_NO_WARNINGS
2
#include<stdio.h>
3
int main()
4
{
5
  int score = 230;
6
  if (score >= 280)
7
  {
8
    printf("能上理工类本科二批\n");
9
  }
10
  else
11
  {
12
    printf("不能上\n");//输出这个
13
  }
14

15
  if (score)
16
  {
17
    printf("能上理工类本科二批\n");//输出这个
18
  }
19
  else
20
  {
21
    printf("不能上\n");
22
  }
23

24
  return 0;
25
}

注意：在C语言中不存在布尔类型，所以C语言采用整型即0与非0代表true和false，示例中第二个if就是判断了非0数据，即true，输出了第一段文字

switch（多选一）#

1
#define _CRT_SECURE_NO_WARNINGS
2
#include<stdio.h>
3
int main()
4
{
5
  char grade;
6
  printf("输入成绩等级\n");
7
  scanf("%c", &grade);
8
  switch (grade)
9
  {
10
  case'A':
11
  case'a':
12
    printf("卓越\n");
13
    break;
14
  case'B':
15
  case'b':
16
    printf("优秀\n");
17
    break;
18
  case'C':
19
  case'c':
20
    printf("良好\n");
21
    break;
22
  case'D':
23
  case'd':
24
    printf("及格\n");
25
    break;
26
  default:
27
    printf("惨不忍睹\n");
28
    break;
29
  }
30
  return 0;
31
}

注意：别忘了break

for（知起止循环）#

1
#define _CRT_SECURE_NO_WARNINGS
2
#include<stdio.h>
3
int main()
4
{
5
  int days;
6
  for (days = 1; days <= 14 + 7; days++) {
7
    //初始化；循环条件；增量变化
8
    printf("隔离第%d天\n",days);
9
    //循环体
10
  }
11
  return 0;
12
}

while（每当型循环）#

1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
int main()
4
{
5
  int money = 1000;
6
  int low = 50;
7
  while (money > low)
8
  {
9
    money -= low;
10
    printf("还剩%d元钱\n", money);
11
  }
12
  return 0;
13
}

do…while（先执行后判断）#

1
#define _CRT_SECURE_NO_WARNINGS
2
#include <stdio.h>
3
int main()
4
{
5
  int workDay = 25;
6
  do
7
  {
8
    workDay -= 1;
9
    printf("距离发工资还有%d天\n",workDay);
10
  } while (workDay >= 1);
11

12
  return 0;
13
}

这是先执行的语句，所以即使不满足条件也会先执行一次，之后再判断

死循环#

现实开发会通过死循环来判断玩家做出什么操作，网络程序中也会不间断查找谁在连接

1
int a = 10;
2
while(a < 20);//空语句占位了循环体
3
{
4
  a += 5;
5
  printf("%d", a);
6
}

1
int a = 10;
2
for (;;) {
3
  a++;
4
  printf("%d\n", a);
5
}

1
xuanshi:
2
  printf("为人民服务\n");
3
  goto xuanshi;

1
while (1)
2
{
3
  printf("为人民服务\n");
4
}

调用命令提示符命令#

1
#define _CRT_SECURE_NO_WARNINGS
2
#include<stdio.h>
3
#include<Windows.h>
4
int main()
5
{
6
  int floor = 25;
7
  while (floor-1) {
8
    floor--;
9
    system("cls");
10
    printf("%d\n", floor);
11
    Sleep(500);
12
  }
13

14
  return 0;
15
}

system后面括号里的内容，表示让命令提示符执行里面的操作，cls代表清空命令提示符的表面内容

sleep表示休眠多少毫秒

运算符#

算术运算符：+ - * / % （）

赋值运算符：= += -= *= /= %= ++ —

关系运算符：> >= < <= == !=

逻辑运算符：! && || （会涉及短路问题）

三目运算符：? :

位运算符：& | ~ ^ << >>（优先级：与>异或>或）

无论是按位与、按位或、按位取反、按位异或、左移、右移，都是对十进制数的补码的每位进行操作

1
char a = 10;
2
char b = -5;
3
a <<= 1;
4
b <<= 1;
5
printf("%hhd %hhd\n", a, b);//20 -10
6
char c = 10;
7
char d = -5;
8
c >>= 1;
9
d >>= 1;
10
printf("%hhd %hhd", c, d);//5 -3

左移补0，右移补符号位

其他运算符：sizeof ,（逗号运算符） &（取地址） *

1
int a = (1,2,3,4,6);
2
int b = 1,2,3,4,6;

a的值是6，b的值是1，有括号称作逗号表达式，没有括号称作逗号语句

逗号表达式的作用是用最右侧的表达式的值代表逗号表达式的值

指针#

地址相关运算#

1
#include <stdio.h>
2
int main()
3
{
4
  int a = 5;
5
  printf("%d\n", &a);
6
  printf("%p\n", &a);
7
  printf("直接访问：%d\n", a);
8
  printf("间接访问：%d\n", *&a);
9
  return 0;
10
}

%p是指针方式打印，也就是十六进制数

&是取地址运算符，*是取值运算符

指针变量#

1
int a = 5;
2
int* p;
3
p = &a;
4
printf("直接访问：%d 间接访问：%d\n", a, *p);

构造指针变量，本例中*p可以完全代替a，比如参与任何的算术运算

注意：*p++表达的意思是p自增1之后再取值，也就是说并不是在原本的那个地址上操作

需要如此操作，需要写成(*p)++

指针变量字节数#

1
char* pc = &a;
2
long long* pll = &a;
3
short* ps = &a;
4
printf("指针大小：%d %d %d %d\n", sizeof(p), sizeof(pc), sizeof(pll), sizeof(ps));//4 4 4 4
5
printf("间接访问的空间大小：%d %d %d %d\n", sizeof(*p), sizeof(*pc), sizeof(*pll), sizeof(*ps));//4 1 8 2

地址都是统一格式，所以都是4字节；

指针的移动#

根据数据类型不同，移动的步伐大小也不同

1
printf("%d %d %d\n", p, p + 1, p + 2);//+4
2
printf("%d %d %d\n", pc, pc + 1, pc + 2);//+1
3
printf("%d %d %d\n", pll, pll + 1, pll + 2);//+8
4
printf("%d %d %d\n", ps, ps + 1, ps + 2);//+2

void 指针#

1
void* pv = &a;

仅用于保留地址，需要时通过强转方式变为任意类型指针

大端与小端#

1
0x123456在内存中的存储方式
2

3
- 大端模式//打印、计算、网络传输
4

5
  低地址 -----> 高地址
6
  0x12 | 0x34 | 0x56
7
- 小端模式//内存
8

9
  低地址 -----> 高地址
10
  0x56 | 0x34 | 0x12

大小端模式各有优势

小端模式强制转换类型时不需要调整字节内容，直接截取低字节即可

大端模式由于符号位为第一个字节，很方便判断正负

注意:

指针不要位移到不属于本程序的内存空间，也不要利用指针改变不属于本程序的内存空间的数据

声明多个指针变量类型时，*不能省略。

指针变量的初始值如果没有明确指向目标用NULL赋值

多级指针#

指向指针的指针

1
int a = 6;
2
int* p = &a;
3
int** pp = &p;
4
int*** ppp = &pp;

数组#

一组同类型变量的集合

名词：成员/元素下标/index/索引长度

1
int age = 10;
2
int ages[5];
3
printf("字节数：%d %d\n", sizeof(int), sizeof(age));//4 4
4
printf("字节数：%d %d\n", sizeof(int[5]), sizeof(ages));//20 20

VS中数组长度不支持设置为变量，可以通过定义足够长，用变量控制有效长度

1
//1  完全初始化
2
int a[4] = { 1,8,6,9 };
3
//2 不完全初始化、其它成员默认 0
4
int b[4] = { 1,8 };
5
int c[4] = { 0 };//清零初始化
6
//3 初始化成员个数 自动决定长度
7
int arr[] = { 1,8,4,2,5,3,4,7 };

计算数组长度

1
int ds[]={10,30,43,43,43,23,12,40};
2
int length=sizeof(ds)/sizeof(ds[0]);

读取地址

1
printf("%d %d %d\n", as, as + 1, as + 2);
2
printf("%d %d %d\n", &as[0], &as[1], &as[2]);

获取内容

1
printf("%d %d %d\n", *as, *(as + 1), *(as + 2));
2
printf("%d %d %d\n", as[0], as[1], as[2]);

折半查找#

1
#include <stdio.h>
2
int main()
3
{
4
  //在一组有序的数列中，寻找一个指定的数字所在的下标
5
  int d[] = {1,5,8,12,23,44,56,78,99,200};
6
  int find=12;
7
  int left = 0;
8
  int right = sizeof(d) / sizeof(d[0]);
9
  int mid;
10
  do
11
  {
12
    mid = (left + right) / 2;
13
    if (d[mid] == find) {
14
      printf("找到了:%d\n",mid);
15
      break;
16
    }
17
    else if (d[mid] < find)left = mid + 1;
18
    else right = mid - 1;
19
  } while (left <= right);
20
  if (!(left <= right))printf("没找到\n");
21

22
  return 0;
23

24
}

约瑟夫问题#

著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决。Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

关键：找出死亡位置

1
i = (i + m - 1) % n;

完整代码

1
#include <stdio.h>
2
int main()
3
{
4
  int r[41] ;
5
  int m=3;//数到几
6
  int n=41;//当前活着的人数
7
  int i=0,j=0,k;
8
  for( k=0;k<41 ;k++ )
9
  {
10
    r[k]=k+1;
11
  }
12
  for (;n>0; n--) {
13
    i = (i + m - 1) % n;
14
    printf("%d \n", r[i]);
15
    for (j = i; j < n-1; j++) {
16
      r[j] = r[j + 1];
17
    }
18
  }
19
  return 0;
20
}

深度理解[ ]#

1
printf("%d %d\n", as[1], 2[as]);
2
printf("%d %d\n", (as + 2)[1], (as + 3)[-1]);

参考地址[偏移] 等同于 *（参考地址+偏移）

所以，2[as]和as[2]是等价的，(as + 2)[1]是as+3偏移也就是下标2的内容

辨析：指针+1与数组名+1

1
int as[]={10,20,30,40,50};
2
int *p;
3
printf("%d %d\n", as + 1, p + 1);//结果相同
4
p++;
5
//as++;

p作为指针变量可以进行+1操作，可以指向任意内存位置

而as作为数组名，是找到数组内存的唯一依据，是地址常量，不可修改

注意：数组名和指针的拆与合

1
for (int i = 0; i < 5; i++) printf("%d %d %d %d\n", as[i], *(as + i), *(p + i), p[i]);

1
as[i] 到 *(as + i)是拆的过程，就是将[]去掉，将运算符和取地址符补齐

1
而*(p + i) 到 p[i]是合的过程，也就是拆的逆过程

利用指针变量实现数组的遍历操作

1
for (int i = 0; i < 5; i++) printf("%d ", *p++);

指针数组#

指针类型的数组简称，每个数组成员都是指针变量

1
int b = 2;
2
int *p[4]={NULL };
3
int arr[4] = { 5,6,7,8 };
4
int* pa[4] = { &b,arr,arr + 1,&arr[3] };
5
for (int i = 0; i < 4; i++)printf("%d\n", *pa[i]);//利用指针数组遍历指向的值

数组指针#

可以指向一组数的指针

1
int a[] = {1,2,3,4};
2
int(*parr)[4]=&a;
3
printf("%d\n", sizeof(*parr));//16

本例中，如果在监视里查看类型

名称	类型	备注
a	int[4]	数组类型
a+0	int *	第0个成员的地址
*(a+0)	int	第0个成员的空间
*a	int	第0个成员的空间
&a	int[4]*	数组类型的地址
&a+1	int[4]*	数组整体偏移，会增加16位

1
int(*parr)[4]=&a;

所以，在上例中写的是=&a，而不是=a，因为&a和左侧内容类型相同，都是数组类型的地址，而a是数组类型

用数组指针访问其中的整数

1
printf("%d\n", (*parr)[0]);
2
printf("%d\n", (*parr)[1]);
3
printf("%d\n", (*parr)[2]);
4
printf("%d\n", (*parr)[3]);

而在笔试题中可能出现

1
将(*parr)[0]利用数组名和指针的拆与合，拆解，*((*parr)+0)，进而优化为**parr

二维数组#

1
数组名[先行][后列]

1
int ge[3][4] = { 0 };
2
int hs = sizeof(ge) / sizeof(ge[0]);
3
int ks = sizeof(ge[0]) / sizeof(int);

数组名用法

1
int arr[3][4]={1,2};
2
//A：找到 某行的首地址
3
printf("%d %d %d\n", arr, arr + 1, arr + 2);
4
//B：得到 某行的存储空间
5
printf("%d %d %d\n", **arr, **(arr + 1), **(arr + 2));
6
//C：找到某行内-某列的地址
7
printf("%d %d %d\n", *(arr + 1), *(arr + 1)+1, *(arr + 1)+2);
8
printf("%d %d %d\n", arr[1],arr[1]+1,arr[1]+2);
9
//D：得到某行 某列的存储空间
10
printf("%d %d %d\n", *(*(arr+1)),*(*(arr+1)+1), *(*(arr + 1) + 2));

利用指向一维数组的指针遍历每一行每一个元素成员

1
int(*ph)[4] = arr;
2
for (int h = 0; h < 3; h++) {
3
  printf("%d %d %d %d\n", **ph, (*ph)[1], *(*ph + 2), (*ph)[3]);
4
  ph++;
5
}

行指针

1
int(*ph)[4] = arr;
2
for (int h = 0; h < 3; h++) {
3
  printf("%d %d %d %d\n", **ph, (*ph)[1], *(*ph + 2), (*ph)[3]);
4
  ph++;
5
}

EasyX#

1
#include<graphics.h>
2
#include<stdlib.h>
3
int main()
4
{
5
  //1 创建画板
6
  initgraph(800, 600,EX_NOCLOSE);//宽800高600的画板
7
  //2 绘画
8
  //外观设置
9
  setlinecolor(GREEN);
10
  setlinestyle(PS_DASH, 2);//虚线
11
  // 再绘图
12
  circle(400, 300, 100);
13
  //3 关闭画板
14

15
  //阻止结束
16
  system("pause");
17

18

19
  return 0;
20
}

EX_NOCLOSE代表easyx生成的界面不能被关闭，只能通过关闭命令提示符来关闭

函数#

函数是对一段流程代码的封装

函数能够增强代码的：可维护性、可阅读性、可复用性。

函数的三种状态：前置声明状态、定义实现状态、调用执行状态。

函数调用才执行，执行完消失依靠于栈，所以在一条语句内分别调用两次函数的话，会先执行后面调用函数的语句

1
int add_all(int a[] )
2
{
3
  int sum=0;
4
  int len=sizeof(a)/sizeof(a[0]);
5
  int i;
6
  for(i=0;i<len;i++)
7
  {
8
    sum+=a[i];
9
  }
10
  return sum;
11
}

本意是想执行数组值累加，但是数组作形参，被识别成了指针变量，所以结果为数组第一个值

第一种解决方法，把数组长度直接告知

1
int add_all(int a[] , int len)

第二种解决方法，传入指针数组逐个读取数组数字，但是只能定长读取

1
int add_all_2(int (*a)[5])
2
{
3
  int sum = 0;
4
  int i;
5
  for (i = 0; i < 5; i++)
6
  {
7
    sum += (*a)[i];
8
  }
9
  return sum;
10
}

函数的传递方式可以称作复制方式，传值时变量名作实参，而传址时变量的地址作实参，相当于把空间传递，指针的间接访问

1
void swap(int*p,int *q)
2
{
3
  int t;
4
  t = *p; *p = *q; *q = t;
5

6
}

函数执行原理#

kernel操作系统内核支持运行环境MSVCRT，运行环境启动exe可执行文件，之后把代码中所有函数加载到内存中的代码区，全局变量放到全局/静态区，之后主函数main进入调用栈，main里的局部变量才会放入栈区

函数名字的本质：代表函数在内存中的地址，作用是找到代码区的代码，()传入实参，才能执行代码区的指令

函数指针#

1
int (*pfun)(int, int);

显式指向函数（传统指针）

1
int (*pfun)(int, int);
2
pfun = &add_int;
3
printf("%d\n", (*pfun)(3, 7));

隐式指向函数

1
int (*padd)(int a, int b) = add_int;
2
printf("%d\n", padd(9,6));

批量执行函数

1
double(*pm)(double) = sqrt;
2
printf("%g", pm(-3.42));
3
pm = fabs;
4
printf("%g", pm(-3.42));
5
pm = ceil;
6
printf("%g", pm(-3.42));
7
pm = floor;
8
printf("%g", pm(-3.42));
9
//用数组批量执行函数
10
double can[4] = { -3.42 ,-3.42 ,-3.42 ,-3.42 };
11
double (*pms[4])(double) = { sqrt,fabs,ceil,floor };
12
for (int i = 0; i < 4; i++) printf("%g\n", pms[i](can[i]));

函数递归#

阶乘

1
#include <stdio.h>
2
int fun01(int n);
3
int main ()
4
{
5
  printf("%d\n",fun01(5));
6
  return 0;
7
}
8
int fun01(int n)
9
{
10
  if (n==1) return 1;
11
  return n*fun01(n-1);
12
}

辗转法求最大公约数

1
#include <stdio.h>
2
int fun11(int m,int n);
3
int main ()
4
{
5
  printf("%d\n",fun11(124,36 ));
6
  return 0;
7
}
8
int fun11(int m,int n)
9
{
10
  if (m % n == 0)return n;
11
  return fun11(n, m % n);
12
}

汉诺塔

1
#include <stdio.h>
2
void fun14(int n, char from,char mid,char to);
3
int main ()
4
{
5
   fun14(10, 'a','b','c');
6
  return 0;
7
}
8

9
void fun14(int n, char from,char mid,char to)
10
{
11
  //终止条件
12
  if (n == 1) {
13
    printf("%c --> %c\n", from, to);
14
    return;
15
   }
16
  //递推逻辑
17
  fun14(n - 1, from, to, mid);
18
  printf("%c --> %c\n", from, to);
19
  fun14(n - 1,mid, from, to);
20
}

extern#

单词本意外部的，表示此变量的定义来自别的源代码文件此处只是使用它

声明此变量在其他外部文件

1
extern int n;

不可以赋值，而变量本身是在其他文件中正常声明即可并分配内存

1
#include "tcsgame.h"
2
#include<stdlib.h>
3
void gameover(void)
4
{
5
  extern int stop;//借用 外部链接声明
6
  stop = 1;
7
  exit(0);//强行关闭程序
8
}

在本例中，stop变量在SnakeGame.cpp中已经被定义，一般作为重构函数者，不建议改动原文件变量位置，所以采用extern

全局变量与局部变量#

1
#include <stdio.h>
2

3
int i ;
4
void fun();
5
int main31 ()
6
{
7
  /*局部变量与全局变量的声明*/
8

9
  /*变量的作用域与生命周期*/
10
  printf("%d\n",i);
11
  fun();
12
  printf("%d\n",i);
13
  fun();
14
  return 0;
15
}
16

17
void fun()
18
{
19
  int i=10;
20
  i++;
21
  printf("%d\n",i);
22
}

i++是对局部变量i进行自增操作（栈区）

局部变量的生命周期是在调用函数时被创造，调用完函数被销毁，而全局变量是程序项目启动被创造，程序项目彻底结束被回收

typedef#

type(类型)def(define，定义)

增强代码可读性

1
typedef unsigned int size_t;

对描述类型过程的封装

1
typedef char KB[1024];
2
KB m, n;
3
typedef int Map[20][30];
4
Map maps[3];//三维数组
5
Map* pm;//指向地图的指针，二维数组指针

指针类型

1
//int* a, b, c;
2
typedef int* P_Int;
3
P_Int a, b, c;

第一行的例子中只有a是指针，要想全设置为指针需要全部加*，自定义P_Int可以实现不用重复书写

函数类型

1
typedef double (*P_Math)(double);
2
P_Math pm[4];

嵌套定义

可以再使用typedef定义typedef定义的类型

枚举#

枚举是数据类型中的扩展类型，是对数据可读性的扩展

枚举值本质就是整数，可方便阅读的整数

1
enum fang_wei{N,S,W,E};//enum 类型名{该类型可能值}
2
enum fang_wei fw = E;

用typedef简化代码

1
typedef enum fang_wei FangWei;
2
FangWei f = N;

代码背后设置enum的数值不一定从0开始，可以乱序

1
typedef enum week{Mon=1,THU,WED,SUN=0}WEEK;
2
WEEK w = WED;

const#

修饰一个变量使之变成常量，即使一开始不赋值，之后也不可以再赋值

1
const int a = 8848;
2
//a = 8898;
3
//a += 2;
4
//a *= 3;
5
//a++;

在VS中，通过间接访问可以修改常量值，但是这种行为不建议且因编译器不同可能会报错

1
const int a = 8848;
2
int* pa = &a;
3
*pa = 9000;

如果将设置常量的语句写在全局范围内，则会在程序启动时被创建于常数区，由于常数区的值只能读取不能修改，所以这次通过间接访问修改则会报错

指向可改内容不可改

1
int m = 3, n = 6;//合法申请的内存空间
2
const int* p = &m;//指针变量 指向空间
3
//*p = 8;//间接访问空间，常量指针
4
p = &n; //改变指向

指向不可改内容可改

1
int m = 3, n = 6;//合法申请的内存空间
2
int* const p = &m;//指针变量 指向空间
3
*p = 8;//间接访问空间
4
//p = &n; //改变指向，指针常量

指向不可改内容不可改

1
int m = 3, n = 6;//合法申请的内存空间
2
const int* const p = &m;//指针变量 指向空间
3
//*p = 8;//间接访问空间
4
//p = &n; //改变指向

宏替换#

1
#include <stdio.h>
2
#define LEN 150//没有分号
3
int main()
4
{
5
  int a[LEN], b[LEN], c[LEN];
6
  return 0;
7
}

就是在预处理期执行查找替换

1
typedef int* PINT;
2
#define Pint int*//定义宏
3
PINT x, y;
4
Pint w, v;//使用宏

上例中，xyw是int*，v是int

1
#define PT printf("hello world");
2
#define A PT PT PT PT PT PT PT PT PT PT
3
#define B A A A A A A A A A A
4
B

上例不用循环实现输出1000个hello world

用宏和typedef创建一个“布尔型数据”

1
typedef int boolean
2
#define true 1
3
#define false 0
4
boolean sex = true;

有参数的宏

1
#define ARRAY_LEN_1(array_name) sizeof(array_name)/sizeof(array_name[0])
2
int arr[] = { 7,9,6,9,85,3,3,8,5 };
3
int len1 = ARRAY_LEN_1(arr);
4
#define ARRAY_LEN_2(array_name,array_type) sizeof(array_name)/sizeof(array_type)
5
double ds[] = { 3.14,2.71828,0.618 };
6
int len2 = ARRAY_LEN_2(ds, double);

一定注意宏里的参数括号与名字之间没有空格

static#

无论创建在全局还是局部，都是和全局变量的生命周期一样程序一开始就创建在全局/静态区

1
#include <stdio.h>
2
void fun41()
3
{
4
  static int c;
5
  int i;
6
  i=10;
7
  i++;
8
  c++;
9

10
  printf("c=%d,i=%d\n",c,i);
11
}
12
int main ()
13
{
14
  fun41();
15
  fun41();
16
  return 0;
17
}

结果c=1，i=11 c=2，i=11

与全局变量的区别#

static的量只能在程序中访问，而全局变量可以通过extern在其他外部程序内访问

可以通过在static定义量所在程序编写get函数，之后在其他程序调用函数即可获得数据

栈与堆#

1
#include <stdio.h>
2
#include <malloc.h>
3
int fun52()
4
{
5
  int* pa = malloc(sizeof(int));
6
  if (pa != NULL)*pa = 10;
7
  return pa;
8
}
9
int main()
10
{
11
  int* p = fun52();
12
  printf("%d\n", *p);
13
  printf("%d\n", *p);
14
  printf("%d\n", *p);
15
  free(p);
16
  p = NULL;
17
  return 0;
18
}

malloc的作用是开辟指定的内存空间，实际上是在堆区开辟指定内存空间，而指针pa是在堆区指向内存空间的

所以这个空间不用了需要及时归还，因为不归还会浪费空间，所以要使用free释放内存，实现完整过程

1
int len = 4;
2
//int arr[len]
3
int* pa = malloc(sizeof(int) * len);
4
pa[0] = 1;
5
pa[1] = 12;
6
pa[2] = 14;
7
pa[3] = 17;
8
free(pa);
9
pa = NULL;

用malloc在堆中申请内存实现数组内设置变量长度

1
int* pa = calloc(len, sizeof(int));

calloc和malloc区别是calloc是清零的初始化，在VC中malloc的清零会写成好多个cd，代表cleaned data

1
pa = realloc(pa, sizeof(int) * len);

用于重新分配内存，最后一个参数是新内存的字节数，是在原位置进行扩建，不是异位置

栈区与堆区的区别#

代数区、常数区、全局/变量区都是程序启动准备状态

堆区、栈区是程序运行时动态调整的，两者对向增长；栈区从高到低，堆区从低到高（增长就是指内存分配，从高到低是指越往后分配内存地址数越低）

	栈区Stack	堆区Heap
分配方式	一次性分配好空间	执行分配函数才分配空间
分配效率	较高	较低（会遍历链表）
存储内容/空间大小	少量临时的分配，一般存放指针	适用更大的数据
管理方式	由操作系统统一维护	更多的是人为管理
碎片	不会产生碎片	会产生碎片（所以需要回收）

字符串#

1
char arr[5] = { 'A',65,'\101','\x41','\n' };
2
printf("%s", arr);

用字符数组创建的数组可以用%s直接遍历打印，但是结束标记不会在数组末尾，导致会多打印许多奇怪的字符

而直接适用string字符串就不会有这种情况，所以字符串和字符数组有一定区别

1
char str1[] ="Hello";
2
char *p1 = "Hello";
3
char *p2="Hello";
4
str1[0]='h';
5
p1[0]='h';//错误
6
p2[0]='h';//错误
7
p1 = "world";
8
//str1 = "world";//错误的

数组在栈区有独立的存储空间，后面修改时直接修改内容

而字符串常量被创建在常量区（只读），通过指针指向常量，指针不能修改常量，所以后面修改时是错误的

所以，可以在字符数组前写上const，让后面改变时编译器直接报错

1
printf("%c\n","how are you"[4]);
2
printf("%s\n","how are you"+4);

输出的是

1
a
2
are you

所以，可以将字符串当成地址看，这样会很好地理解

strlen#

1
#include <string.h>
2
char str1[] ="Hello";
3
printf("%d\n", sizeof(str1));//6
4
printf("%d\n", strlen(str1));//5

strlen不计\0的结束标记空间

sizeof计\0的结束标记空间

strcpy#

1
#include <string.h>
2
char a[20];
3
strcpy(a, "hello");
4
printf("%s\n", a);
5
printf("%s\n", strcpy(a, "hi"));

strcpy_s

1
char a[20];
2
printf("%d\n", strcpy_s(a, 10, "how are you"));
3
printf("%d\n", strcpy_s(a, 30, "how are you"));

会对添加的新字符串长度和被更新的字符数组进行检验，上下两条指令均会崩溃

1
char * p="12345";
2
printf("%s\n", strncpy(a, p, 4));
3
strncpy_s(a, 20, p, 4);

strncpy对指定长度进行替换，并且后面不会加\0，而安全用法是验证被替换字符串长度需大于指定长度

strcat#

1
#include <string.h>
2
char a[50]="hello ";
3
char *p="hi ";
4
strcat(a, p);
5
printf("%s\n", a);
6
printf("%s\n", strcat(a, "world."));
7
/*strcat_s*/
8
strcat_s(a, 50, "c++");
9
printf("%s\n", a);
10
/*strncat*/
11
printf("%s\n", strncat(a, "ABCDE", 4));
12
/*strncat_s*/
13
strncat_s(a, 50, "abcdefg", 3);
14
printf("%s\n", a);

实现字符串的拼接，其余功能类上

strcmp#

1
#include <string.h>
2
printf("%d\n", strcmp("java", "python"));//-1
3
printf("%d\n", strcmp("r", "python"));//1
4
printf("%d\n", strcmp("apple", "apple"));//0

strcmp是通过比较字符串中首个字符的ASCII码的大小，前面大则输出1，相等输出0，后面大则输出-1

stricmp不是标准库函数，可以实现忽略大小写字母的比较

1
printf("%d\n", stricmp("APPLE", "apple"));//0

strstr#

1
char* p = "how do you do";
2
const char* pdo = strstr(p, "do");
3
printf("%s\n", pdo);//do you do
4
printf("%d\n", pdo - p);//4
5
pdo = strstr(p, "did");//找不到返回空指针

strstr用于搜索字符串在另一个字符串中首次出现的位置（内存地址）

类型转换#

1
char str[10];
2
/*itoa*/
3
itoa(1234, str, 10);
4
printf("%d %o %x %s\n", 185, 185, 185, itoa(185, str, 2));
5
/*atoi,atof atol*/
6
int n = atoi("1899");
7
double pi = atof("3.14159");
8
long long b = atoll("789789165513");

a代表ASCII，最后一个数字代表进制数

利用printf使任意数字转字符串

1
char str[10];
2
sprintf(str,"%.3f",3.1415926);//3.142
3
sprintf(str,"lld",3141592653);

键盘输入#

1
#include <stdio.h>
2
#include <string.h>
3
#include <stdlib.h>
4
char c;
5
char a[300];
6
/* 输入一个字符*/
7
scanf("%c", &c);
8
scanf_s("%c", &c, 1);
9
c = getchar();
10
c = getchar();
11
c = _getch();
12
c = getche();
13
for (int i = 0; i < 6; i++) {
14
  c = _getch();
15
  putchar('#');
16
}

getchar()输入可以修改，需要换行确认，因为换行符也在缓冲区，所以要多准备一个getchar()给换行符

_getch()无需确认，立即被读取，屏幕不显示输入内容

_getche()无需确认，立即被读取，屏幕显示输入内容

用循环可以实现掩盖真实内容的方式进行输入

通过scanf输入一个字符串和一个字符

1
scanf("%s%c", a, &c);
2
scanf("%s %c", a, &c);
3
scanf_s("%s %c", a, 300, &c, 1);//安全格式

如果输入过程中需要空格间隔时，一定体现出来，否则会将空格识别成单字符

使用scanf无法读取字符串中的空格，所以采用以下方式

1
gets_s(a,300);

也可以使用文件读取方式

1
fgets(a,300,stdin);
2
a[strlen(a)-1] = '\0';
3
puts(a);

但是，这种方式会读取\n，所以要采用第二行的方式将\n改为\0

stdin表示标准输入（键盘）

结构体#

1
typedef enum card_type {SFZ=8,XSZ,JSZ} CardType;
2
struct stu_info
3
{
4
  int stuNum;
5
  CardType cardType;
6
  char cardNum[20];
7
  char name[30];
8
  char sex;
9
}s1,s2;
10
struct stu_info s3, s4;
11
struct stu_info s3 = { 3,SFZ,"110101200001010011","ZhangSan",'M' },
12
        s4 = { .name = "LiSi",.sex = 'F' };
13
scanf_s("%d%d%s%s %c", &s1.stuNum, &s1.cardType, s1.cardNum, 20, s1.name, 30, &s1.stuNum);

注意枚举的定义形式、结构体的定义形式、结构体的两种使用方式和全赋值部分赋值的方式

用typedef简化结构体定义形式

1
typedef struct book
2
{
3
  char bookName[20];
4
  char writer[30];
5
  int year;
6
  double price;
7
}BOOK;
8
int main ()
9
{
10
  BOOK books[2] = {
11
    {"活着", "余华", 2000, 15.6},
12
    {"三体", "刘慈欣", 2000, 30.0}
13
  };
14
  for (int i = 0; i < 2; i++) {
15
    printf("%-12s %-8s %6d %7.2f\n",
16
      books[i].bookName,
17
      books[i].writer,
18
      books[i].year,
19
      books[i].price);
20
  }
21

22
  return 0;
23
}

结构体指针的三种形式

1
typedef BOOK* Pbook;
2
int main ()
3
{
4
  struct book* p1 = books;
5
  BOOK* p2 = books + 1;
6
  Pbook p3 = &books[1];
7
}

struct具有对齐机制

默认向其中的每一个属性分配属性中所需最大单个的内存，能使用的正常分配，有剩余的下一个继续使用，不够的继续往下开辟4字节内存存储，即使后续有更小的内存可以将上述剩余的空间补齐，也不能跳回使用

注意，数组长度不计，仅以数据类型为依据进行区分，而指针变量本质是保留地址号，地址号长短和x86（4字节）和x64（8字节）有关

对齐机制实例

1
#include <stdio.h>
2
struct HH//12
3
{
4
  int a;
5
  short c;
6
  short d;
7
  char e;
8
  char b;
9
  short f;
10
}  ;
11
struct FF//12
12
{
13
  char a[5];
14
  char *e;
15
}  ;
16
int main  ()
17
{
18
  printf("%d\n",sizeof(struct HH));
19
    printf("%d\n",sizeof(struct FF));
20
  return 0;
21
}

位域

按照位域机制分配的存储空间会以紧挨着的形式进行按位分配，断开是指重开辟一个数据类型的空间继续存放后续的数据

1
#include <stdio.h>
2
typedef struct
3
{
4
   int a:2;//a变量占两个位的存储空间 但int会分配4个字节。
5
   int b:8;
6
   int c:2;
7
   int :0;//断开
8
   int d:2;
9

10
}  TT;
11
int main   ()
12
{
13
  TT t ;
14
  printf("%d\n",sizeof(TT));//8
15
    t.a = 9;
16
    printf("%hhd",t.a);//1  因为9是0000 1001 取后两位即01，符号位0 数字位1，所以是1
17
  return 0;
18
}

共用体

共用体的特点是共享空间，而结构体是各自有各自的空间，对齐补齐机制类似于结构体

1
#include <stdio.h>
2
union aa
3
{
4
  int a ;
5
  char b;
6
} ;
7
int main()
8
{
9
  union aa h;
10
  h.a=65;
11
  printf("共用体大小%d\n",sizeof(union aa));//4
12
  printf("%c\n",h.b);//A
13
  return 0;
14
}

链表#

声明节点

1
typedef struct node
2
{
3
  int data;//数据域
4
  struct node * next;//下一个节点
5
} Node, *P_NODE;

创建节点变量、链接节点

1
Node n1 = { 0,NULL };
2
Node n2 = { 2,NULL };
3
Node n3 = { 4,NULL };
4
Node n4 = { 5,NULL };
5
//链接所有节点
6
n1.next = &n2;
7
n2.next = &n3;
8
n3.next = &n4;

遍历链表

1
Node* p = &n1;
2
while (p != NULL) {
3
  printf("%d\n", p->data);
4
  p = p->next;
5
}

上面创建的链表是在栈区创建的，但更多时候需要在堆区创建

1
#include <malloc.h>
2
P_NODE p1 = malloc(sizeof(Node));
3
p1->data = 0;
4
p1->next = NULL;

用更快捷的方式链接链表

1
PNode create(int data)
2
{
3
  PNode newnode = malloc(sizeof(Node));
4
  newnode->data = data;
5
  newnode->next = NULL;
6
  return NULL;
7
}
8
PNode header = NULL;
9
PNode ender = NULL;
10
void add(PNode node)
11
{
12
  if (header == NULL)
13
  {
14
    header = node;
15
    ender = node;
16
  }
17
  else
18
  {
19
    ender->next = node;
20
    ender = node;
21
  }
22
}

插入节点（后插入）

1
void insert_behind(int index, PNode node)
2
{
3
  PNode p = header;
4
  for (int i = 0; i < index; i++)
5
  {
6
    p = p->next;
7
  }
8
  PNode q = p->next;
9
  node->next = q;
10
  p->next = node;
11
}

文件#

1
#include<stdio.h>
2
#include<stdlib.h>
3
int main()
4
{
5
  FILE* readFile = fopen("d:\\bbb.txt","rb");
6
  if (readFile)//如果文件打开成功
7
  {
8
    fclose(readFile);//关闭文件流。
9
    readFile=NULL;//释放文件指针。
10
  }
11
  else
12
  {
13
    printf("文件不存在\n");
14
  }
15
  return 0;
16
}

rb代表只读（r）二进制文件（b）

1
FILE* pf = fopen("d:/myfile/黑名单.txt", "wt");
2
if (pf != NULL)
3
{
4
  puts("创建成功");
5
  fclose(pf);
6
  pf = NULL;
7
}
8
else
9
{
10
  puts("创建失败");
11
}

用w只写模式，若改成at就是追加，即在原有文本之后再写后续内容

1
int r;
2
r = rename("d:/myfile/黑名单.txt", "d:/myfile/白名单.txt");
3
printf("%s %d\n", r == 0 ? "成功修改" : "失败", r);

给文件改名

1
r = remove("d:/myfile/白名单.txt");
2
printf("%s %d\n", r == 0 ? "成功删除" : "删除失败", r);

删除文件

文件处理模板

1
FILE* pf = fopen("", "");
2
if (pf != NULL)
3
{
4

5

6
  fclose(pf);
7
  pf = NULL;
8
}

能向屏幕打印的就能打印到文件里

1
printf("beijing time %02d : %02i\n", 9, 57);
2
puts("hello world");
3
putchar('*');
4

5
fprintf(pf, "beijing time %02d : %02i\n", 9, 57);
6
fputs("hello world", pf);
7
fputc('*', pf);

读取若干整数

1
FILE* pf = fopen("d:/myfile/cj.txt", "rt");
2
if (pf != NULL)
3
{
4
  int n;//char str[20];
5
  while(!feof(pf) && fscanf(pf, "%d"/*%s*/, &n) > 0){//不是文件尾部 并且数据读取成功
6
    printf("%d\n", n);//puts(str);
7
  }
8
  fclose(pf);
9
  pf = NULL;
10
}

用注释标注的内容体现出读取若干行文字的代码

文件光标

1
FILE* pf = fopen("d:/myfile/zm.txt", "r+t");//r+ 读写
2
if (pf != NULL)
3
{
4
  printf("光标位置：ld\n", ftell(pf));//0
5
  char ch = fgetc(pf);
6
  printf("光标位置：ld\n", ftell(pf));//1
7
  char str[10];
8
  fscanf(pf, "%5s", str);
9
  printf("光标位置：%ld\n", ftell(pf));//6
10
  fclose(pf);
11
  pf = NULL;
12
}

回到开头

1
rewind(pf);

任意定位

1
fpos_t wz = 12;
2
fsetpos(pf, &wz);//将光标定位到第12个（从0开始）

修改光标位置的数据

1
//三个参数：文件指针，偏移量，参考位置
2
//修改数据一定要进行修改重定位（fseek）
3
fseek(pf, 0, SEEK_CUR);//定位在当前光标位置
4
fputc('r', pf);//将r覆盖在原先的字符上
5
fseek(pf, 0, SEEK_SET);//定位在开头处位置
6
fputc('a', pf);
7
fseek(pf, -5, SEEK_END);//定位在结尾处位置之前的五个位置
8
fputc("hello", pf);
9
fclose(pf);
10
pf = NULL;

向二进制文件进行写入操作整型变量

1
FILE * writeFile=fopen("d:\\data.txt","wb");
2
int n = -1;
3
int m = 0x41424344;
4
fwrite(&n, sizeof(int), 1, writeFile);
5
fwrite(&m, sizeof(int), 1, writeFile);//DCBA，小端存储所导致

写入数组

1
int arr[5] = { 97,98,10,48,100 };
2
fwrite(arr, sizeof(int), 5, writeFile);
3
fwrite(arr, sizeof(int[5]), 1, writeFile);//等价的写法

读操作

1
FILE * readFile=fopen("d:\\data.txt","rb");
2
//1 读取一个整型变量
3
int a;
4
fread(&a, sizeof(int), 1, readFile);
5
printf("%d\n", a);
6
fread(&a, sizeof(int), 1, readFile);
7
printf("%x\n", a);//十六进制
8
//2 读取一个数组
9
int arr[30];
10
int count = fread(arr, sizeof(int), 30, readFile);//成功读取的数量
11
for (int i = 0; i < count; i++) printf("%d\n", arr[i]);

文件复制

1
FILE * from = fopen("d:\\白名单.txt","rb");
2
FILE * to = fopen("d:\\bmd.txt","wb");
3
unsigned char buffer[1024];
4
int len;//实际读取的长度
5
if (from != NULL && to != NULL)
6
{
7
  while ((len = fread(buffer, sizeof(char), 1024, from)) > 0)
8
  {
9
    fwrite(buffer, sizeof(char), len, to);
10
  }
11
  fclose(from);
12
  fclose(to);
13
  from = to = NULL;
14
}

文件复制原理：从文件来源（from）经过临时存储（buffer），一般一次运输千字节，运到复制到目标（to）

如果这篇文章对你有帮助，欢迎分享给更多人！

C 语言学习笔记：从基础语法到文件操作

https://joyanblog.com/posts/c-language-notes/

作者

Joyan

发布于

2026-07-15

许可协议

CC BY-NC-SA 4.0

Linux 网络编程（1）：网络基础模型

test

Joyan 的 blog

C 语言学习笔记：从基础语法到文件操作#

C 与 C++ 的区别#

常用配置与函数#

关闭安全提示#

数学函数#

随机数#

清空键盘缓冲区#

入门与开发环境#

基本程序框架#

main函数的唯一性#

快捷键#

开始执行（不调试）#

替换#

调取提示#

转到定义#

printf 格式化输出#

格式占位符的写法#

基本数据类型#

计算机存储基本概念#

进制#

内存存储原理：原码、反码、补码#

例题#

浮点#

浮点数的乘除法#

浮点数的打印#

类型转换#

字符型#

scanf 格式化输入#

浮点数的 scanf#

工作原理#

scanf 的返回值#

源代码执行原理#

流程结构#

if（二选一）#

switch（多选一）#

for（知起止循环）#

while（每当型循环）#

do…while（先执行后判断）#

死循环#

调用命令提示符命令#

运算符#

指针#

地址相关运算#

指针变量#

指针变量字节数#

指针的移动#

void 指针#

大端与小端#

多级指针#

数组#

折半查找#

约瑟夫问题#

深度理解[ ]#

指针数组#

数组指针#

二维数组#

EasyX#

函数#

函数执行原理#

函数指针#

函数递归#

extern#

全局变量与局部变量#

typedef#

枚举#

const#

宏替换#

static#

与全局变量的区别#

栈与堆#

栈区与堆区的区别#

字符串#

strlen#

strcpy#

strcat#

strcmp#

strstr#

类型转换#

键盘输入#