二、共用体
2.1 共用体的引入目的
当需要将多个变量共享同一块内存时,可以使用共用体
2.2 定义及初始化
1> 概念:
由相同数据类型或不同数据类型构成的集合,但是,该集合中的成员共享同一块内存空间
2> 定义格式
union 结构体名称
{
成员类型1 成员变量1;
成员类型2 成员变量2;
。。。
成员类型n 成员变量n;
};
3> 共用体初始化
1、共用体初始化方式跟结构体初始化方式一致
2、共用体变量初始化时,只给定一个值即可,就是第一个成员的值
4> 共用体访问成员跟结构体一致
5> 共用体成员中可以包含基本数据类型,也可以包含构造数据类型
6> 共用体变量的大小,是所有成员中占内存最大的成员的大小
7> 共用体变量一般不作为函数 参数传递
8> 举个例子
#include<myhead.h>
//定义共用体类型
union Info
{
char value_a;
int value_b;
double value_c;
};
int main(int argc, const char *argv[])
{
//测试共用体类型的大小
printf("sizeof union Info = %ld\n", sizeof(union Info)); //8
//定义共用体变量
union Info temp = {30}; //只需要初始化一个值
//访问成员
temp.value_a = 100;
//printf("value_a = %d\n", temp.value_a); //100
temp.value_b = 520;
//printf("value_a = %d\n", temp.value_b); //
temp.value_c = 3.14;
printf("value_c = %.2lf\n", temp.value_c); //3.14
printf("value_b = %d\n", temp.value_b); //520?
printf("value_a = %c\n", temp.value_a); //100?
return 0;
}
9> 实战常用例子
#include<myhead.h>
//定义共用体类型
union Info
{
char ch; //字符数据
int num; //整形数据
} temp;
int main(int argc, const char *argv[])
{
//使用共用体判断自己的主机的大小端问题
temp.num = 0x12345678;
//判断temp.ch的值即可
if(temp.ch == 0x12)
{
printf("big edinan\n");
}else if(temp.ch == 0x78)
{
printf("little endian\n");
}
return 0;
}
10> 共用体变量的各个成员的地址和共用体变量都是同一地址
三、类型重定义
3.1 引入目的
当程序员写程序时,可能会因为数据类型的问题,在定义变量时,导致该程序比较晦涩难懂,例如:unsigned long int ,struct Stu
为了提高代码的简洁性,以及为了更加方便理解使得代码更加优雅,我们可以将这些类型重新起一个简洁好记的名字
3.2 使用方式
1> 类型重定义,我们引入了关键字 typedef
2> 使用方式: typedef 旧名字 新名字;
例如:typedef unsigned long int uint64;
3.3 目前所接触的数据类型
1> 总结定义的变量
int a; //定义一个普通变量,变量名为 a
int arr[5]; //定义一个长度位5的整型数组,数组名位arr
int *ptr; //定义一个一级指针变量,变量名为ptr
int **pptr; //定义了一个二级指针变量,变量名为pptr
int *ptr_arr[5]; //定义一个长度为5的指针数组,数组名为ptr_arr
int (*arr_ptr)[5]; //定义了一个数组指针,指向长度为5的数组,变量名为arr_ptr
int (*fun_ptr)(void); //定义了一个函数指针变量,指向返回值为int参数为空的函数,变量名为fun_ptr
int (*fun_ptr_arr[5])(void); //定义了一个函数指针数组,数组名为fun_ptr_arr
struct Info {...} buf; //定义了一个结构体变量
2> 提取类型
int ; //定义一个普通变量类型
int [5]; //定义一个长度位5的整型数组类型
int *; //定义一个一级指针变量类型
int **; //定义了一个二级指针变量类型
int *[5]; //定义一个长度为5的指针数组类型
int (*)[5]; //定义了一个数组指针类型
int (*)(void); //定义了一个函数指针变量类型
int (*[5])(void); //定义了一个函数指针数组类型
struct Info {...} ; //定义了一个结构体类型
3> 将上面类型进行重定义
typedef int a; //定义一个普通变量,变量名为 a
typedef int arr[5]; //定义一个长度位5的整型数组,数组名位arr
typedef int *ptr; //定义一个一级指针变量,变量名为ptr
typedef int **pptr; //定义了一个二级指针变量,变量名为pptr
typedef int *ptr_arr[5]; //定义一个长度为5的指针数组,数组名为ptr_arr
typedef int (*arr_ptr)[5]; //定义了一个数组指针,指向长度为5的数组,变量名为arr_ptr
typedef int (*fun_ptr)(void); //定义了一个函数指针变量,指向返回值为int参数为空的函数,变量名为fun_ptr
typedef int (*fun_ptr_arr[5])(void); //定义了一个函数指针数组,数组名为fun_ptr_arr
typedef struct Info {...} buf; //定义了一个结构体类型
实例:
#include<myhead.h>
typedef int int32; //给int类型重新起个名字
typedef int * ptr; //给int *重新命名
typedef int arr[5]; //给int [5] 重新命名
typedef int (*arr_ptr)[5]; //给数组指针重命名
typedef struct Stu
{
char name[20]; //姓名
int age;
double score;
}Stu; //给结构体重新命名
int main(int argc, const char *argv[])
{
int32 num = 520; //使用重命名的类型定义变量
printf("sizeof num = %ld\n", sizeof(num)); //4
ptr p = # //定义的p是一个指针变量
printf("sizeof p = %ld\n", sizeof(p)); //8
arr a = {1,2,3,4,5}; //此时a就是一个数组名,长度为5
printf("sizeof a = %ld\n", sizeof(a)); //20
arr_ptr ap; //此时ap就是一个数组指针变量
ap = &a;
printf("sizeof ap = %ld\n", sizeof(ap)); //8
Stu s = {"二狗", 20, 80}; //定义一个结构体变量
printf("sizeof s = %ld\n", sizeof(s)); //32
return 0;
}
4> #define 与 typedef的区别
1、#define是宏定义,使用宏名取代字符串,typedef是进行类型重命名,要求必须给定的是数据类型
2、#define是预处理指令,在预处理时,进行替换,typedef时C语言语句,发生在程序执行阶段 3、在使用上面两种方式命名一个变量时,没有太大区别,但是,命名多个指针类型时,就有区别了
#include<myhead.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;
}
5> 类型重定义,也可以连续定义
#include<myhead.h>
typedef int my_int, *my_ptr; //表示 my_int 是int类型, my_ptr 是int *类型
typedef struct Node
{
int data; //数据域
struct Node *next; //指针域
}Node, *Node_ptr; //类型重定义两个名字
//此后,Node定义的变量是结构体普通变量
//Node_ptr定义的变量是结构体指针变量
int main(int argc, const char *argv[])
{
my_int num = 520;
my_ptr ptr = #
printf("sizeof(num) = %ld, sizeof(ptr) = %ld\n", sizeof(num), sizeof(ptr));
printf("sizeof(Node) = %ld, sizeof(Node_ptr) = %ld\n", \
sizeof(Node), sizeof(Node_ptr));
return 0;
}
四、内存划分
1> 一个进程一旦启动后,操作系统会为其分配 4G 的虚拟内存
2> 分为两部分:内核空间(1G高地址)、用户空间(3G低地址)
3> 多个进程独立拥有0--3G的用户空间,共享3--4G的内核空间
3> 用户空间又分为多个部分,具体如同所示
4> 通过指令:cat /proc/进程ID/maps 可以查看当前进程的内存分布
564a73455000-564a73456000 r-xp 00000000 08:01 402924 /home/ubuntu/24061/数据结构/day2/a.out //对应 .text段
564a73655000-564a73656000 r--p 00000000 08:01 402924 /home/ubuntu/24061/数据结构/day2/a.out //对应 .ro段
564a73656000-564a73657000 rw-p 00001000 08:01 402924 /home/ubuntu/24061/数据结构/day2/a.out //对应 .bss 和 .data段
564a7451b000-564a7453c000 rw-p 00000000 00:00 0 [heap] //对应堆区
7f22cfd55000-7f22cff3c000 r-xp 00000000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so //动态库的空间
7f22cff3c000-7f22d013c000 ---p 001e7000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so
7f22d013c000-7f22d0140000 r--p 001e7000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so
7f22d0140000-7f22d0142000 rw-p 001eb000 08:01 924106 /lib/x86_64-linux-gnu/libc-2.27.so
7f22d0142000-7f22d0146000 rw-p 00000000 00:00 0
7f22d0146000-7f22d016d000 r-xp 00000000 08:01 924078 /lib/x86_64-linux-gnu/ld-2.27.so
7f22d0358000-7f22d035a000 rw-p 00000000 00:00 0
7f22d036d000-7f22d036e000 r--p 00027000 08:01 924078 /lib/x86_64-linux-gnu/ld-2.27.so
7f22d036e000-7f22d036f000 rw-p 00028000 08:01 924078 /lib/x86_64-linux-gnu/ld-2.27.so
7f22d036f000-7f22d0370000 rw-p 00000000 00:00 0
7ffe04466000-7ffe04487000 rw-p 00000000 00:00 0 [stack] //栈区
7ffe04595000-7ffe04598000 r--p 00000000 00:00 0 [vvar]
7ffe04598000-7ffe04599000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0 [vsyscall] //内核空间
5> 使用指令:pmap -d 进程id号 可以查看当前进程所有的空间分配大小
6> 案例说明
#include<myhead.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;
}
五、动态内存分配和回收
1> 对于堆区空间的数据,我们也可以利用起来,对于栈区的内存空间,会随着所在的函数空间的结束而结束
2> 可以在堆区由程序员手动申请一片内存来使用,其生命周期到程序员手动释放该空间为止,或者整个程序结束
3> 对堆区空间的使用函数
#include <stdlib.h>
void *malloc(size_t size);
功能:在堆区申请出给定字节大小的空间,并返回该空间的内存起始地址
参数:要申请的空间大小,以字节为单位
返回值:成功分配空间后,返回该空间的起始地址,失败返回NULL
注意:由于返回结果是一个万能指针,想要使用该内存中的内容时,需要转换为具体的指针
void free(void *ptr);
功能:释放给定的堆区空间
参数:堆区空间的起始地址
返回值:无
#include <stdlib.h>
void *malloc(size_t size);
功能:在堆区申请出给定字节大小的空间,并返回该空间的内存起始地址
参数:要申请的空间大小,以字节为单位
返回值:成功分配空间后,返回该空间的起始地址,失败返回NULL
注意:由于返回结果是一个万能指针,想要使用该内存中的内容时,需要转换为具体的指针
void free(void *ptr);
功能:释放给定的堆区空间
参数:堆区空间的起始地址
返回值:无
练习:
在堆区申请5个int类型的内存空间,用于存储5个学生的成绩定义函数实现:完成学生成绩的录入、输出、排序
#include<myhead.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;
}
六、预处理指令
1> 预处理指令,执行在分步编译的预处理阶段,所有的预处理指令都是以#开头,没有分号结束
2> 文件包含指令:相当于将引入的文件中的内容,在引入部分写了一份
1、 #include<stdio.h> :直接使用的是系统提供的头文件 /usr/include
#include"myhed.h" :从当前路径下,找该头文件,如果有,则直接使用,如果没有再向系统库中找
2、头文件中:主要完成函数的声明、全局变量的定义、结构体类型的声明
3> 宏定义指令:就是定义一个常量,用宏名表示后面的字符串,使用中,只替换不计算不做正确性检测
1、#define 宏名 字符串
2、#define 宏名(参数) 含参字符串
3、#undef 宏名 :表示取消宏定义
#include<myhead.h>
#define MAX 40
int main(int argc, const char *argv[])
{
printf("%d\n", MAX); //使用宏 40
#undef MAX
#define MAX 100
printf("%d\n", MAX); //100
return 0;
}
4> 条件编译
1、 #if 数据
程序代码;
#endif
判断数据是否为真,如果为真,则编译程序代码,否则不编译程序代码
2、#if 数据
程序代码1;
#elif
程序代码2;
#endif
判断数据是否为真,如果为真,编译程序代码1,否则编译程序代码2
3、#ifdef 宏名
程序代码;
#endif
判断宏明是否被定义,如果有该宏名,则编译程序代码,否则不编译
4、#ifndef 宏名
程序代码;
#endif
判断宏明是否被定义,如果没有该宏名,则编译程序代码,否则不编译
//防止头文件重复包含
#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; //定义一个全局变量
#endif
5> 分文件编译
作业
完成学生信息管理系统
要求:定义一个班级,包括多个学生,以及记录实际学生的个数
#define MAX 100 //最大容量
//定义学生类型
struct Stu
{
char name[20];
int age;
double score;
};
//定义班级类型
struct Class
{
struct Stu student[MAX]; //存放学生的容器
int size; //实际人数
};
1> 完成班级的创建,创建时,需要传递班级实际人数
2> 完成班级学生的信息录入工作
3> 完成将班级学生按成绩进行降序排序工作
4> 输出班级中成绩最好和最差学生的信息
5> 完成信息的输出工作
6> 完成班级的销毁工作
要求:班级创建在堆区,尽量分文件编译完成
test1.c
#include "test.h"
int main()
{
int num;
printf("请输入班级人数:");
scanf("%d", &num);
struct Class *cls = create_class(num);
input_students(cls, num);
sort_students(cls);
print_best_and_worst(cls);
print_all_students(cls);
destroy_class(cls);
cls=NULL;
return 0;
}
test2.c
#include "test.h"
// 创建班级
struct Class *create_class(int size)
{
struct Class *new_class = (struct Class *)malloc(sizeof(struct Class));
if (new_class == NULL)
{
printf("内存分配失败!\n");
exit(1);
}
new_class->size = size;
return new_class;
}
// 录入学生信息
void input_students(struct Class *cls, int num)
{
for (int i = 0; i < num; i++)
{
printf("请输入第%d个学生的姓名,年龄和成绩:", i + 1);
scanf("%s %d %lf", cls->student[i].name,&cls->student[i].age,&cls->student[i].score);
}
}
// 按成绩降序排序
void sort_students(struct Class *cls)
{
for (int i = 0; i < cls->size - 1; i++)
{
for (int j = 0; j < cls->size - 1 - i; j++)
{
if (cls->student[j].score < cls->student[j + 1].score)
{
struct Stu temp = cls->student[j];
cls->student[j] = cls->student[j + 1];
cls->student[j + 1] = temp;
}
}
}
printf("排序成功\n");
}
// 输出成绩最好和最差的学生信息
void print_best_and_worst(struct Class *cls)
{
printf("成绩最好的学生:\n");
printf("姓名:%s\t", cls->student[0].name);
printf("年龄:%d\t", cls->student[0].age);
printf("成绩:%.2lf\n", cls->student[0].score);
printf("成绩最差的学生:\n");
printf("姓名:%s\t", cls->student[cls->size - 1].name);
printf("年龄:%d\t", cls->student[cls->size - 1].age);
printf("成绩:%.2lf\n", cls->student[cls->size - 1].score);
}
// 输出所有学生信息
void print_all_students(struct Class *cls)
{
for (int i = 0; i < cls->size; i++)
{
printf("第%d个学生的信息:\n", i + 1);
printf("姓名:%s\t", cls->student[i].name);
printf("年龄:%d\t", cls->student[i].age);
printf("成绩:%.2lf\n", cls->student[i].score);
}
}
// 销毁班级
void destroy_class(struct Class *cls)
{
free(cls);
cls=NULL;
}
test.h
#ifndef TEST_H
#define TEST_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 100
struct Stu
{
char name[20];
int age;
double score;
};
struct Class
{
struct Stu student[MAX];
int size;
};
// 创建班级
struct Class *create_class(int size);
// 录入学生信息
void input_students(struct Class *cls, int num);
// 按成绩降序排序
void sort_students(struct Class *cls);
// 输出成绩最好和最差的学生信息
void print_best_and_worst(struct Class *cls);
// 输出所有学生信息
void print_all_students(struct Class *cls);
// 销毁班级
void destroy_class(struct Class *cls);
#endif // TEST_H