CDay09
动态内存分配
在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。
相关函数
malloc函数
//原型：
void* malloc( size_t size );
//功能：
分配size字节未初始化的内存
//参数：
size - 要分配的字节数
//返回值：
成功时，返回指向新分配内存的指针。为避免内存泄漏，必须用 free() 或 realloc() 解分配返回的指针。
失败时，返回空指针。
calloc函数
//原型：
void* calloc( size_t num, size_t size );
//功能：
为 num 个对象的数组分配内存，并初始化所有分配存储中的字节为零。（申请size * num字节内存）
//参数：
num - 对象数目
size - 每个对象的大小
//返回值：
成功时，返回指向新分配内存的指针。为避免内存泄漏，必须用 free() 或 realloc() 解分配返回的指针。
失败时，返回空指针。
realloc函数
//原型：
void *realloc( void *ptr, size_t new_size );
//功能：
重新分配给定的内存区域。它必须是之前为 malloc() 、 calloc() 或 realloc() 所分配，并且仍未被 free 或 realloc 的调用所释放。
//参数：
ptr - 指向需要重新分配的内存区域的指针
new_size - 数组的新大小（字节数）
//返回值：
成功时，返回指向新分配内存的指针。返回的指针必须用 free() 或 realloc() 归还。原指针 ptr 被非法化，而且任何通过它的访问是未定义行为（即使重分配是就地的）。
失败时，返回空指针。原指针 ptr 保持有效，并需要通过 free() 或 realloc() 归还。
注意事项
1、ptr必须是以前通过malloc、realloc、calloc函数返回的指针
2、若重新分配内存在原有内存基础上缩小，则直接截断
3、若重新分配内存在原有内存基础上扩大，则优先尽力在原地扩容，如无法原地扩容，则重新在堆里找一块内存进行分配，并将原有数据复制过来后，将原来那片内存free掉。
有关内存的释放（free函数）
如果申请的内存没有被释放，会造成内存泄漏
//例子：
p = malloc(...);
q = malloc(...);
p = q;
内存泄漏：如果程序中存在垃圾，这种现象就叫做内存泄漏。
Q：如何避免内存泄漏？ ---及时释放不再用到的内存空间
//原型：
void free( void *ptr );
//功能：
解分配之前由 malloc() 、 calloc()或 realloc() 分配的空间。
//参数：
ptr - 指向要解分配的内存的指针(malloc() 、 calloc()或 realloc()的返回值)
//返回值：
无
Q：free函数如何知道该释放多大的内存空间？
A：free释放的时候会根据传入的地址向前偏移4个字节 从这4字节获取具体的内存块大小并释放。 （实际上的实现很可能使用8字节做为头部：其中每四个字节分别标记大小和是否正在使用）
引入free函数后，可以减少内存泄漏，但是同时也引入了一个新的问题：悬空指针
p = malloc(...);
q = p;
free(p);
注意：
-
若 ptr 为空指针，则函数不进行操作。
-
若 ptr 的值不等于之前从 malloc() 、 calloc() 、 realloc() 或 aligned_alloc() (C11 起) 返回的值，则行为未定义。
-
若 ptr 所指代的内存区域已经被解分配，则行为未定义，即是说已经以ptr 为参数调用 free() 或 realloc() ，而且没有后继的 malloc() 、 calloc() 或 realloc() 调用以 ptr 为结果。
-
若在 free() 返回后通过指针 ptr 访问内存，则行为未定义（除非另一个分配函数恰好返回等于 ptr 的值）。
有关通用指针与空指针
void*：通用指针，可以指向任意类型的对象，同时也可以转换为其他类型的指针。
空指针：不能指向任何对象的指针（用宏NULL表示空指针，其值为0）。所以不能对空指针进行解引用，否则会报NULLPointer Exception（空指针异常）
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
示例
//拼接两个字符串，但是不改变其中任何一个字符串
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char* myStrcat(const char*, const char*);
int main(void)
{
char str1[] = "Hello ";
char str2[] = "World!";
char* resultStr = myStrcat(str1, str2);
puts(resultStr);
free(resultStr);
return 0;
}
char* myStrcat(const char* str1, const char* str2)
{
char* resultStr = malloc(strlen(str1) + strlen(str2) + 1); //1是'\0'
if (resultStr == NULL)
{
printf("Error: malloc failed in myStrcat!");
exit(1);
}
//内存分配成功
strcpy(resultStr, str1);
strcat(resultStr, str2);
return resultStr;
}
动态内存分配是链式结构的基础
链表：用一条 “链” 将所有结点串联起来的结构。
结点：数据域、指针域（存放另一个结点的地址）
链表的分类：
示例：
#include<stdio.h>
#include<stdlib.h>
typedef struct node {
int data;
struct node* next;
}Node;
Node* add_to_list(Node* list, int data);
int main(void)
{
Node* list = NULL;
list = add_to_list(list, 3); // 3
list = add_to_list(list, 2); // 2 --> 3
list = add_to_list(list, 1); // 1 --> 2 --> 3
while (list)
{
printf("%d ", list->data);
list = list->next;
}
return 0;
}
// 头插法
Node* add_to_list(Node* list, int data)
{
//申请空间
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL)
{
printf("malloc failed in add_to_list function!\n");
exit(1);
}
newNode->data = data;
newNode->next = list;
return newNode;
}
二级指针
原则：
如果想修改 指针变量 的值 --> 传递二级指针
如果想修改 指针变量指向的对象 的值 --> 传递一级指针
示例：
#include<stdio.h>
#include<stdlib.h>
typedef struct node {
int data;
struct node* next;
}Node;
void add_to_list(Node** list, int data);
int main(void)
{
Node* list = NULL;
add_to_list(&list, 3); // 3
add_to_list(&list, 2); // 2 --> 3
add_to_list(&list, 1); // 1 --> 2 --> 3
while (list)
{
printf("%d ", list->data);
list = list->next;
}
return 0;
}
// 头插法
void add_to_list(Node** plist, int data)
{
//申请空间
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL)
{
printf("malloc failed in add_to_list function!");
exit(1);
}
newNode->data = data;
newNode->next = *plist;
*plist = newNode;
}
函数指针
指向函数的指针
#include<stdio.h>
#include<math.h>
#define PI 3.1415926
double average(double (*f)(double), double a, double b);
int main(void)
{
double result = average(&sin, 0, PI); // 等价于 average(sin, 0, PI)
printf("%lf", result);
return 0;
}
double average(double (*f)(double), double a, double b)
{
return (*f)((a + b) / 2); // 等价于 f((a + b) / 2)
}
/*
* 注：函数指针与数组类似，函数名可以作为指针使用。
*/
qsort函数
-
如果comp返回值小于0（< 0），那么p1所指向元素会被排在p2所指向元素的左面；
-
如果comp返回值等于0（= 0），那么p1所指向元素与p2所指向元素的顺序不确定；
-
如果comp返回值大于0（> 0），那么p1所指向元素会被排在p2所指向元素的右面。
#include<stdio.h>
#define SIZE(a) (sizeof(a)/sizeof(a[0]))
typedef struct student {
int no;
char name[25];
int chinese;
int math;
int english;
}Student;
typedef struct node {
int data;
struct node* next;
} Node;
int cmp(const void*, const void*); //比较函数
int main(void)
{
Student students[5] = {
{3, "wangyuyan", 100, 90, 90},
{1, "liuyifei", 100, 100, 100},
{2, "zhaolinger", 90, 100, 100},
{5, "xiaolongnv", 90, 90, 100},
{4, "xixi", 90, 100, 90} };
qsort(students, SIZE(students), sizeof(students[0]), cmp);
return 0;
}
// 比较规则：先比较总分大小(逆序)， 再比较语文成绩(逆序)，再比较数学(逆序)，比较英语成绩(逆序)，比较学号(顺序)
int cmp(const void* p1, const void* p2) {
Student* s1 = p1;
Student* s2 = p2;
int total1 = s1->chinese + s1->math + s1->english;
int total2 = s2->chinese + s2->math + s2->english;
if (total1 != total2) {
return total2 - total1;
}
if (s1->chinese != s2->chinese) {
return s2->chinese - s1->chinese;
}
if (s1->math != s2->math) {
return s2->math - s1->math;
}
if (s1->english != s2->english) {
return s2->english - s1->english;
}
return s1->no - s2->no;
}
链表
单链表的基本操作
1、增（在某个结点的后面添加）--------------O(1)
newNode->next = cur->next;
cur->nex = newNode;
2、删（在某个结点后删除）--------------O(1)
cur->next = cur->next->next;
3、查
-
根据索引查找元素 ----------O(n)
-
查找链表与特定值相等的元素 ----------O(n)
-
元素大小有序 ----------O(n)
-
元素大小无序 ----------O(n)
-
双向链表的基本操作
1、增加（在某个结点前面添加） ----------O(1)
2、删除（删除该结点） ----------O(1)
3、查找
-
查找前驱结点 ----------O(1)，单链表O(n)
-
根据索引查找值 ----------O(n)
- 单链表：平均遍历 n/2
- 双向链表：平均遍历 n/4
-
查找链表中与特定值相等的元素，有序无序都是O(n)
比较单链表与双向链表
- 双向链表会占用更多的内存空间
- 双向链表的性能会优于单链表
在实际工程中，一般会使用双向链表
