c语言（14）—数据结构（2）内存管理-优快云博客

一、结构体补充

1.结构体数组：数据类型数组名[元素个数]

2.结构体数组初始化：

全部初始化：

struct student s[3] = {

{"zhangsan", 'm', 19, 100},

{"lisi", 'f', 18, 90},

{"wanger", 'm', 19, 60},

};

局部初始化：

struct student s[3] = {

        [1] = {
                        .name = "zhangsan",
                        .score = 90,
                },
};

3.结构体数组传参：int fun(struct student *pstu, int len)

注：接受时应该在同时使用gets和scanf时要在最后加上getchar（）

e.g.

  1 #include <stdio.h>                                                                          
  2 
  3 struct student{
  4     char name[32];
  5     char sex;
  6     int age;
  7     int score;
  8 };
  9 
 10 int PutAllStuInfo(struct student *pstu, int len)
 11 {
 12     int i = 0;
 13 
 14     for(i = 0; i < len; i++)
 15     {
 16         printf("姓名：%s\n", pstu->name);
 17         printf("性别：%c\n", pstu->sex);
 18         printf("年龄：%d\n", pstu->age);
 19         printf("成绩：%d\n", pstu->score);
 20         pstu++;
 21     }
 22 
 23     return 0;
 24 }
 25 
 26 int main(void)
 27 {
 28     struct student s[3] = {
 29         {"zhangsan", 'm', 18, 90},
 30         {"lisi", 'm', 19, 50},
 31         {"wangwu", 'f', 16, 60},
 32     };
 33     struct student stu[3] = {
 34         [0] = {
 35             .name = {"zhangsan"},
 36             .score = 20,
 37         },
 38     };
 39 
 40     PutAllStuInfo(s, 3);
 41 
 42     return 0;

二、共用体

1. 共用体也称为联合体，共用体每个成员变量的空间共享的，结构体每个成员变量的空间是独立的，多用于函数传参使用

2.数据类型定义

union 共用体名 {
数据类型1 成员变量1;
数据类型2 成员变量2;
数据类型3 成员变量3;
...
};

e.g.

  1 #include <stdio.h>
  2 
  3 union s{
  4     char a;
  5     short b;
  6     int c;
  7 };
  8 
  9 int main(void)
 10 {
 11     union s s1;
 12 
 13     s1.a = 'A';
 14     printf("%c\n", s1.a);
 15 
 16     s1.b = 100;
 17     printf("%d\n", s1.b);
 18 
 19     s1.c = 9000;
 20     printf("%d\n", s1.c);
 21                                                       
 22     return 0;
 23 }

3. 使用共用体判断内存大小端

内存低地址存放低数据位，内存高地址存放高数据位，内存小端

内存低地址存放高数据位，内存高地址存放低数据位，内存大端

判断过程：union的字节长度是由内部数据类型最长长度决定的，char类型就会在较长数据类型的首地址位，可以通过这个原理判断。

  1 #include <stdio.h>
  2 
  3 union s{
  4     char a;
  5     int b;
  6 };
  7 
  8 int main(void)
  9 {
 10     union s s1;
 11 
 12     s1.b = 1;
 13     if(s1.a)
 14     {
 15         printf("内存小端\n");
 16     }
 17     else
 18     {
 19         printf("内存大端\n");
 20     }
 21 
 22     return 0;                                         
 23 }

三、枚举

定义形式

enum 枚举类型 {
常量1,
常量2,
常量3,
...
};

注：枚举常量均为int类型，且第一个枚举常量的值默认为0，后续枚举常量的值总是前一个常量的
值+1，枚举常量可以在定义时被赋值

  1 #include <stdio.h>
  2 
  3 enum weekday {
  4     M = 1,
  5     TU,
  6     WE,
  7     TH,
  8     FR,
  9     SA,
 10     SU,
 11 };
 12 
 13 int main(void)
 14 {
 15     enum weekday day;
 16 
 17     printf("请输入几天是周几：\n");
 18     scanf("%d", (int *)&day);
 19 
 20     switch (day)
 21     {
 22         case M:printf("尾号1和6限行\n");break;    //常量名可以直接用                                                                                                               
 23         case TU:printf("尾号2和7限行\n");break;
 24         case WE:printf("尾号3和8限行\n");break;
 25         case TH:printf("尾号4和9限行\n");break;
 26         case FR:printf("尾号5和0限行\n");break;
 27         case SA:
 28         case SU:printf("不限行\n");
 29     }
 30 
 31     return 0;
 32 }

四、位运算符

1、 &按位与：与0得0，| 按位或：或1置1

^异或：相同为0，相异为1

<<左移：让数据变大，等价于 * 2^n

>>右移：让数据缩小，等价于 / 2^n

^异或：可以实现不使用第三方变量完成两个数的交换

2. 位运算符优先级：移位运算符优先级高于其余位运算符

e.g.实现a与b值的交换

思路：a^a=0

a^0=a

  1 #include <stdio.h>
  2 
  3 int main(void)
  4 {
  5     int a = 100;
  6     int b = 200;
  7 
  8     a = a ^ b;
  9     b = a ^ b;
 10     a = a ^ b;
 11 
 12     printf("a = %d, b = %d\n", a, b);                                              
 13 
 14     return 0;
 15 }

3. 使用场景：

将一个数据第n位置1：num |= (1 << n);

将一个数据某位置0 :num &= ~(1 << n);

五、内存管理

1. 堆区由程序员管理（申请、释放）

2.堆区空间操作：

malloc函数：申请一段堆区空间，成功返回申请堆区空间首地址，失败返回NULL

free函数：释放申请的堆区空间

3.内存泄漏：只申请空间，使用完毕后，不释放空间，导致可用空间越来越少，这样会产生内存泄露

e.g.1（每次申请过后一定要回收）

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 int main(void)
  5 {
  6     int *p = NULL;
  7 
  8     p = malloc(4);  //申请一段４字节的空间                                         
  9     if(NULL == p)
 10     {
 11         printf("malloc failed\n");
 12         return -1;
 13     }
 14 
 15     *p = 100;
 16 
 17     printf("*p = %d\n", *p);
 18 
 19     free(p);
 20 
 21     return 0;
 22 }

e.g.2 使用堆区空间打印字符串

注：此处只能用strcpy，直接对p赋值会改变地址

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>                                                                
  4 
  5 int main(void)
  6 {
  7     char *p = NULL;
  8 
  9     p = malloc(32);
 10     if(NULL == p)
 11     {
 12         printf("malloc failed\n");
 13         return -1;
 14     }
 15 
 16     strcpy(p, "hello world");
 17 
 18     printf("p = %s\n", p);
 19 
 20     free(p);
 21 
 22     return 0;
 23 }
~