共用体
1、引用目的：当需要多个变量共享同一块内存时，可以使用共用体
2、定义及初始化
概率：由相同或不同数据类型构成的集合，但是，该集合中的成员共享同一内存
定义格式：
union 结构体名称
{
成员类型1 成员变量1;
成员类型2 成员变量2；
。。。
成员类型n 成员变量n;
};
3、共用体初始化
共用体初始化参数化与结构体一致
但是，共用体只有一个内存，初始化时，给定一个值即可，即第一个成员的值
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? 输出的是“3.14”解码的一部分
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;
}
类型重定义
1、引用目的：
当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，
例如:unsigned long int,struct stu
为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字
2、使用方式
1）类型重定义，我们引入了关键字 typedef
2）使用方式: typedef 名字 新名字;
例:typedef unsigned long int uint64;
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 Mysturct
{
....
}
2）提取类型
int ; //定义一个普通变量类型
int [5]; //定义一个长度位5的整型数组类型
int *; //定义一个一级指针变量类型
int **; //定义了一个二级指针变量类型
int *[5]; //定义一个长度为5的指针数组类型
int (*)[5]; //定义了一个数组指针类型
int (*)(void); //定义了一个函数指针变量类型
int (*[5])(void); //定义了一个函数指针数组类型
struct Mysturct mystrucr
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
struct Mysturct mystrucr
示例：
#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和tpyedef的区别
通过宏定义改名
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));
//4 8
printf("sizeof(Node) = %ld, sizeof(Node_ptr) = %ld\n", sizeof(Node), sizeof(Node_ptr));
//16 8
return 0;
}
内存划分
1、一个进程一旦启动后，操作相同会为其分配 4G 的虚拟内存
2、分为两部分：内核空间（1G高地址）、用户空间（3G地址）
3、多个进程独立拥有0—3G用户空间，共享3—4的内核空间
4、用户空间分为多个部分：
大致划分
5、通过指令:cat /proc/进程ID/maps 可以查看当前进程的内存分布
pidof a.out 查看进程标识
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] //内核空间
6、使用指令： pmap -d 进程id号 可以查看当前进程所有的空间分配大小
7、案例说明
#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、对堆区空间使用的函数：malloc、free
#include <stdlib.h>
void *malloc(size_t size);
功能：在堆区申请出给定字节大小的空间，并返回该空间的内存起始地址
参数：要申请的空间大小，以字节为单位
返回值：成功分配空间后，返回该空间的起始地址，失败返回NULL
注意：由于返回结果是一个万能指针，想要使用该内存中的内容时，需要转换为具体的指针
void free(void *ptr);
功能：释放给定的堆区空间
参数：堆区空间的起始地址
返回值：无
#include<myhead.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;
}
4、堆区空间使用例
#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 宏名 //取消宏定义4、条件编译指令
1、 #if 数据
程序代码；
#endif
判断数据是否为真，如果为真，则编译程序代码，否则不编译程序代码
2、#if 数据
程序代码1;
#elif
程序代码2；
#endif
判断数据是否为真，如果为真，编译程序代码1，否则编译程序代码2
3、#ifdef 宏名
程序代码；
#endif
判断宏明是否被定义，如果有该宏名，则编译程序代码，否则不编译
4、#ifndef 宏名
程序代码；
#endif
判断宏明是否被定义，如果没有该宏名，则编译程序代码，否则不编译5、分文件编译
作业
1、完成班级的创建，创建时，需要传递班级实际人数
2、完成班级学生的信息录入工作
3、完成将班级学生按成绩进行降序排序工作
4、输出班级中成绩最好和最差学生的信息
5、完成信息的输出工作
6、完成班级的销毁工作
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX 50
struct Xue_sheng_guan_li
{
int xuehao;
char mingzi[20];
char xinbie[4];
double chengji;
};
struct Class
{
struct Xue_sheng_guan_li stu[MAX];
int n;
};
// 信息录入
void lu_ru(struct Class *arr)
{
if (arr == NULL)
{
printf("error\n");
return;
}
printf("输入录入学生人数:");
scanf("%d", &arr->n);
for (int i = 0; i < arr->n; i++)
{
printf("第%d个学生的学号:", i + 1);
scanf("%d", &arr->stu[i].xuehao);
printf("第%d个学生的姓名:", i + 1);
scanf("%s", arr->stu[i].mingzi);
printf("第%d个学生的性别:", i + 1);
scanf("%s", arr->stu[i].xinbie);
printf("第%d个学生的成绩:", i + 1);
scanf("%lf", &arr->stu[i].chengji);
putchar(10);
}
}
// 信息查看
void da_ying(struct Class *arr)
{
if (arr == NULL)
{
printf("error\n");
return;
}
printf("学生信息:\n");
printf("学号\t名字\t性别\t成绩\n");
for(int i = 0; i < arr->n; i++)
{
printf("%d\t%s\t%s\t%.2lf\n", arr->stu[i].xuehao, arr->stu[i].mingzi, arr->stu[i].xinbie, arr->stu[i].chengji);
}
}
// //输出最成绩信息
void zui_cj(struct Class *arr)
{
int max_cj = arr->stu[0].chengji;
struct Xue_sheng_guan_li max_xx;
for (int i = 0; i < arr->n; i++)
{
if (max_cj < arr->stu[i].chengji)
max_xx = arr->stu[i];
}
printf("成绩最好的是%s,成绩:%.2lf\n", max_xx.mingzi, max_xx.chengji);
int min_cj = arr->stu[0].chengji;
struct Xue_sheng_guan_li min_xx;
for (int i = 0; i < arr->n; i++)
{
if (min_cj > arr->stu[i].chengji)
min_xx = arr->stu[i];
}
printf("成绩最差的是%s,成绩:%.2lf\n", min_xx.mingzi, min_xx.chengji);
}
// // 排序
void pai_xu(struct Class *arr, int k)
{
if (k)
{
for (int i = 1; i < arr->n; i++)
{
for (int j = 0; j < arr->n - i; j++)
{
if (arr->stu[j].chengji > arr->stu[j + 1].chengji)
{
struct Class temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
else
{
for (int i = 1; i < arr->n; i++)
{
for (int j = 0; j < arr->n - i; j++)
{
if (arr->stu[j].chengji < arr->stu[j + 1].chengji)
{
struct Class temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
//free释放
void zha_xue_xiao(struct Class *arr)
{
free(arr);
arr = NULL;
}
// 菜单函数
void printf_menu()
{
printf("\t\t=====1,学生信息录入\n");
printf("\t\t=====2,查看学生信息\n");
printf("\t\t=====3,成绩最好的学生和成绩最差的学生\n");
printf("\t\t=====5,按成绩升序排序\n");
printf("\t\t=====7,炸学校\n");
printf("\t\t=====0,退出\n");
}
int main()
{
struct Class *a = (struct Class *)malloc(sizeof(struct Class));
memset(a, 0, sizeof(struct Class));
if (a == NULL)
printf("error\n");
while (1)
{
// menu
int menu = 10;
printf_menu(); // 调用菜单函数
printf("输入功能代码\n");
scanf("%d", &menu);
switch (menu)
{
case 1:
{
lu_ru(a);
}
break;
case 2:
{
da_ying(a);
}
break;
case 3:
{
zui_cj(a);
}
break;
case 5:
{
int k = 0;
printf("降序:0,升序:1\n");
scanf("%d", &k);
pai_xu(a, k);
}
break;
case 7:
{
zha_xue_xiao(a);
}
break;
case 0:
{
return 0;
}
break;
default:
{
printf("输入有误，请重新输入\n");
}
break;
}
}
return 0;
}
扫一扫
343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
