目录
思维导图：
学习内容：
1. 共用体
1.1 引入目的
当需要将多个变量共享同一块内存时，可以使用共用体。
1.2 定义及初始化
1.2.1 概念
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间
1.2.2 定义格式
union 结构体名称
{
成员类型1 成员变量1;
成员类型2 成员变量2；
。。。
成员类型n 成员变量n;
};1.2.3 初始化
1、共用体初始化方式跟结构体初始化方式一致
2、共用体变量初始化时，只给定一个值即可，就是第一个成员的值
1.2.4 变量的大小
是所有成员中占内存最大的成员的大小
例子：
#include<stdio.h>
union Info
{
char c;
int num;
}temp;
int main(int argc, char const *argv[])
{
temp.num=0x12345678;
if(temp.c==0x12)
{
printf("big duan");
}else if (temp.c==0x78)
{
printf("little duan");
}
return 0;
}
2. 类型重定义
2.1 使用方法
当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu
为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。
2.2 使用方式（也可以连续定义）
2.2.1 类型重定义
引入了关键字 typedef
2.2.2 使用方式
typedef 旧名字 新名字；
例如：typedef unsigned long int uint64;
3.#define 与 typedef的区别
1、#define是宏定义，使用宏名取代字符串，typedef是进行类型重命名，要求必须给定的是数据类型
2、#define是预处理指令，在预处理时，进行替换，typedef时C语言语句，发生在程序执行阶段
3、在使用上面两种方式命名一个变量时，没有太大区别，但是，命名多个指针类型时，就有区别了
例如：
#include<stdio.h>
#define my_int int * //宏定义
typedef int * My_int; //类型重定义
int main(int argc, const char *argv[])
{
my_int a,b; //定义两个变量 int a,b;
//int *a, b;
My_int m,n; //定义两个普通变量 int m,n;
//int *a; int *b;
printf("sizeof a = %ld, sizeof b = %ld\n", sizeof(a), sizeof(b));
printf("sizeof m = %ld, sizeof n = %ld\n", sizeof(m), sizeof(n));
return 0;
}
4. 内存划分
1> 一个进程一旦启动后，操作系统会为其分配 4G 的虚拟内存
2> 分为两部分：内核空间（1G高地址）、用户空间（3G低地址）
3> 多个进程独立拥有0--3G的用户空间，共享3--4G的内核空间
4> 用户空间又分为多个部分，具体如同所示
5. 通过指令：cat /proc/进程ID/maps 可以查看当前进程的内存分布
6. 使用指令：pmap -d 进程id号 可以查看当前进程所有的空间分配大小
7.查看进程号：运行程序，输入pidof a.out，可以查看进程id。
例如：
#include<stdio.h>
int num; //在全局区的 .bss
static int key; //在全局区的 .bss
int num_1 = 520; //在全局区的 .data， 520在.ro段
char *ptr = "hello"; //ptr在全局区的.data段，"hello"在.ro段
int main(int argc, const char *argv[])
{
int value; //栈区，随机值
static int value_1; //在全局区的 .bss段
static int value_2 = 1314; //value_2在全局区的.data段， 1314在.ro段
return 0;
}5. 动态内存分配和回收
5.1 使用函数
#include <stdlib.h>
void *malloc(size_t size);
功能：在堆区申请出给定字节大小的空间，并返回该空间的内存起始地址
参数：要申请的空间大小，以字节为单位
返回值：成功分配空间后，返回该空间的起始地址，失败返回NULL
注意：由于返回结果是一个万能指针，想要使用该内存中的内容时，需要转换为具体的指针
void free(void *ptr);
功能：释放给定的堆区空间
参数：堆区空间的起始地址
返回值：无#include<stdio.h>
int main(int argc, const char *argv[])
{
//申请1字节空间
char *ptr = (char *)malloc(1); //在堆区申请1字节大小的空间
//ptr占8字节，在栈区
//malloc(1) 申请的是堆区空间
printf("*ptr = %d\n", *ptr); //0
*ptr = 100; //给堆区空间进行赋值
printf("*ptr = %d\n", *ptr); //100
//申请4字节空间大小
int *qtr = (int *)malloc(sizeof(int)); //单个数据申请
printf("*qtr = %d\n", *qtr); //0
//连续数据的申请
int *dtr = (int *)malloc(sizeof(int) * 5);
for(int i=0; i<5; i++)
{
printf("%d\t", dtr[i]);
}
printf("\n");
//释放空间
free(ptr);
free(qtr);
free(dtr);
ptr = NULL;
qtr = NULL;
dtr = NULL;
return 0;
}例如：
在堆区申请5个int类型的内存空间，用于存储5个学生的成绩
定义函数实现：
完成学生成绩的录入、输出、排序
解析：
#include<stdio.h>
//定义申请空间的函数
int *create()
{
//在堆区申请5个int类型的空间大小
int *ptr = (int *)malloc(sizeof(int) * 5);
if(NULL == ptr)
{
printf("申请失败\n");
return NULL;
}
//程序执行至此，表示内存申请成功
//给内存空间进行初始化
memset(ptr, 0, sizeof(int)*5);
//将内存地址返回
return ptr;
}
//成绩的录入
void input(int *ptr)
{
//完成录入
if(NULL == ptr)
{
printf("录入失败\n");
return ;
}
//正常录入工作
for(int i=0; i<5; i++)
{
printf("请输入第%d个学生的成绩:", i+1);
scanf("%d", &ptr[i]);
}
printf("录入成功\n");
}
//输出成绩
void output(int *ptr)
{
//判断逻辑
if(NULL == ptr)
{
printf("error\n");
return ;
}
//正常输出
printf("学生分数分别是：");
for(int i=0; i<5; i++)
{
printf("%d\t", ptr[i]);
}
printf("输出结束\n");
}
//定义排序函数
void sort(int *ptr)
{
//判断逻辑
if(NULL == ptr)
{
printf("error\n");
return ;
}
//排序
for(int i=1; i<5; i++)
{
for(int j=0; j<5-i; j++)
{
if(ptr[j] < ptr[j+1])
{
int temp = ptr[j];
ptr[j] = ptr[j+1];
ptr[j+1] = temp;
}
}
}
printf("排序成功\n");
}
//释放内存的函数
void destroy(int *ptr)
{
//释放内存
if(NULL != ptr)
{
free(ptr); //释放空间
ptr = NULL;
}
}
/*********************主程序***********************/
int main(int argc, const char *argv[])
{
//调用创建函数，创建一个成绩表
int * P = create();
if(NULL == P)
{
return -1;
}
//调用录入函数
input(P);
//调用输出函数
output(P);
//排序函数
sort(P);
//输出成绩
output(P);
//释放内存的函数
destroy(P);
P = NULL;
//调用输出函数
output(P);
return 0;
}6. 预处理指令
6.1 预处理指令
执行在分步编译的预处理阶段，所有的预处理指令都是以#开头，没有分号结束
6.2 文件包含指令
相当于将引入的文件中的内容，在引入部分写了一份
例如：
1、 #include<stdio.h> :直接使用的是系统提供的头文件
#include"myhed.h" :从当前路径下，找该头文件，如果有，则直接使用，如果没有再向系统库中找
2、头文件中：主要完成函数的声明、全局变量的定义、结构体类型的声明。
6.3 宏定义指令
定义一个常量，用宏名表示后面的字符串，使用中，只替换不计算不做正确性检测.
1、#define 宏名 字符串
2、#define 宏名（参数） 含参字符串
3、#undef 宏名 ：表示取消宏定义
6.4 条件编译
1、 #if 数据
程序代码；
#endif
判断数据是否为真，如果为真，则编译程序代码，否则不编译程序代码
2、#if 数据
程序代码1;
#elif
程序代码2；
#endif
判断数据是否为真，如果为真，编译程序代码1，否则编译程序代码2
3、#ifdef 宏名
程序代码；
#endif
判断宏明是否被定义，如果有该宏名，则编译程序代码，否则不编译
4、#ifndef 宏名
程序代码；
#endif
判断宏明是否被定义，如果没有该宏名，则编译程序代码，否则不编译6.5 防止头文件重复编译
//防止头文件重复包含
#ifndef TEST_H
#define TEST_H
int *create() ; //创建函数的声明
void input(int *ptr); //录入函数的声明
void output(int *ptr) ; //输出函数的声明
void sort(int *ptr); //排序函数的声明
void destroy(int *ptr) ; //销毁函数的声明
int num = 520; //定义一个全局变量
#endif6.6 分文件编译
课外作业：
完成学生信息管理系统
要求：定义一个班级，包括多个学生，以及记录实际学生的个数
1> 完成班级的创建，创建时，需要传递班级实际人数
2> 完成班级学生的信息录入工作
3> 完成将班级学生按成绩进行降序排序工作
4> 输出班级中成绩最好和最差学生的信息
5> 完成信息的输出工作
6> 完成班级的销毁工作
要求：班级创建在堆区，尽量分文件编译完成
解析：
主函数：zy.c
/******************主函数*****************/
#include<stdio.h>
#include<string.h>
#include "text.h"
#include <stdlib.h>
int main(int argc, char const *argv[])
{
int menu=0;
int size =0 ;
printf("请输入班级实际人数：");
scanf("%d",&size); //输入实际人数
struct Class *cls = create(size); //获取Class
while (1)
{
//提示用户输入功能
print_menu();
scanf("%d",&menu);
switch (menu)
{
case 1:
enterstu(cls);
break;
case 2:
print_stu(cls);
break;
case 3:
maxminstu(cls);
break;
case 4:{
destroy(cls);
cls = NULL;
print_stu(cls);
}
break;
case 5:
sortstu(cls);
break;
case 0: goto END;
default:printf("您输入的功能有误，请重新输入\n");
}
}
END:
return 0;
}
调用函数 text.c
/********************************调用函数**********************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 100 //最大容量
//定义学生类型
struct stu
{
char name[20];
int age;
int score;
};
//定义班级类型
struct Class
{
struct stu student[MAX]; //存放学生的容器
int size; //实际人数
};
struct Class *create(int count){
struct Class *cls = (struct Class *)malloc(sizeof(struct Class));
cls->size = count;
if(NULL == cls)
{
printf("申请失败\n");
return NULL;
}
//程序执行至此，表示内存申请成功
//给内存空间进行初始化
memset(cls, 0, sizeof(int)*(count));
//将内存地址返回
return cls;
}
//菜单
void print_menu(){
printf("\n学生管理系统\n");
printf("功能1：完成对学生信息的录入\n");
printf("功能2：完成对学生信息的输出\n");
printf("功能3：输出成绩最高和最低学生的信息\n");
printf("功能4：班级的销毁\n");
printf("功能5：对学生信息按成绩进行降序排序\n");
printf("功能0：退出\n");
printf("请选择操作（0-5）：");
}
//定义学生录用信息函数
int enterstu(struct Class *stu){
for (int i = 0; i < stu->size; i++) // 循环遍历输入各个学生信息
{
printf("输入学生 %d 的姓名：", i + 1);
scanf("%s",stu->student[i].name);
printf("输入学生 %d 的年龄：", i + 1);
scanf("%d",&stu->student[i].age);
printf("输入学生 %d 的成绩：", i + 1);
scanf("%d",&stu->student[i].score);
}
}
//求出学生成绩最大最小值函数
void maxminstu(struct Class *stu){
int maxscore=0; //定义初始值
int minscore=0; //定义初始值
for (int i = 0; i < stu->size; i++)
{
//判断最大值
if(stu->student[i].score >stu->student[maxscore].score) {
maxscore = i;
}
//判断最小值
if(stu->student[i].score < stu->student[minscore].score){
minscore = i;
}
}
//打印输出成绩最大最小值的信息
printf("最高成绩的名字为%s,年龄为%d,成绩为%d\n",stu->student[maxscore].name,stu->student[maxscore].age,stu->student[maxscore].score);
printf("最低成绩的名字为%s,年龄为%d,成绩为%d\n",stu->student[minscore].name,stu->student[minscore].age,stu->student[minscore].score);
}
//打印学生信息函数
void print_stu(struct Class *stu){
if(NULL == stu)
{
printf("error\n");
return ;
}
printf("姓名\t年龄\t成绩\n");
for (int i = 0; i < stu->size; i++) // 循环遍历学生信息，打印出来
{
printf("%s\t%d\t%d\n",stu->student[i].name,stu->student[i].age,stu->student[i].score);
}
}
//排序函数
void sortstu(struct Class *stu){
for(int i = 1; i < stu->size; i++){ //交换三部曲
for(int j = 0; j < stu->size-i; j++){
if(stu->student[j].score > stu->student[j+1].score){
struct stu temp = stu->student[j];
stu->student[j] = stu->student[j+1];
stu->student[j+1] = temp;
}
}
}
print_stu(stu);
}
//释放内存的函数
void destroy(struct Class *stu)
{
//释放内存
if(NULL != stu)
{
free(stu); //释放空间
stu = NULL;
}
}头文件：text.h
/************************头文件*******************/
struct Class *create(int count);
void print_menu();
int enterstu(struct Class *stu);
void maxminstu(struct Class *stu);
void print_stu(struct Class *stu);
void sortstu(struct Class *stu);
void destroy(struct Class *stu);
