C动态内存管理

malloc
calloc
realloc
free

原则：谁申请，谁释放，防止内存泄漏

#include<stdio.h>
#include<stdlib.h>

int mian()
{
	int * p =NULL;
	p = malloc(sizeof(int));
	if(p == NULL)
	{
		printf("malloc() error!\n");	
		exit(1);
	}
	*p = 10;
	printf("%d\n",*p);
	free(p);
	exit(0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include<stdio.h>
#include<stdlib.h>

int mian()
{
	in *p;
	int i;
	int num 5;
	
	p = malloc(sizeof(int)*num);
	for(i = 9;i< num;i++)
		scanf("%d",&p[i]);
	for(i = 0;i<num;i++)
		printf("%d ",p[i]);
	printf("\n");
	
	exit(0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在C语言中，当你传递一个指针给一个函数时，你实际上是传递了指针的副本，而不是指针本身。这意味着，虽然你在函数内部可以通过这个指针修改指向的内存，但对于指针本身的修改（例如将它指向一个新的内存地址），这种修改不会影响到函数外部指针的值。

#include <stdio.h>
#include <stdlib.h>

void func(int *p) {
    // 修改指针指向的内容
    *p = 42;
    
    // 修改指针本身的值（只会影响到函数内部的指针）
    p = NULL;
}

int main() {
    int x = 0;
    int *p = &x;

    printf("Before: %d\n", *p);  // 输出: 0
    func(p);
    printf("After: %d\n", *p);   // 输出: 42

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<stdio.h>
#include<stdlib.h>

void func(int *p,int n)
{
	p = malloc(n);
	if(p == NULL)
		exit(1);
	return ;
}

int main()
{
	int *p =NULL;
	printf("%d",&p);
	int num = 100;
	
	func(p,num);
	free(p);
	
	exit(0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<stdio.h>
#include<stdlib.h>

void func(int **p,int n)
{
	*p = malloc(n);
	if(p == NULL)
		exit(1);
	return ;
}

int main()
{
	int *p =NULL;
	printf("%d",&p);
	int num = 100;
	
	func(&p,num);
	free(p);
	
	exit(0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<stdio.h>
#include<stdlib.h>

void *func(int *p,int n)
{
	p = malloc(n);
	if(p == NULL)
		exit(1);
	return p;
}

int main()
{
	int *p =NULL;
	printf("%d",&p);
	int num = 100;
	
	p = func(p,num);
	free(p);
	
	exit(0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

malloc

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int n = 5;

    arr = (int*)malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

易错点：

忘记检查malloc返回值是否为NULL，从而导致程序在内存分配失败时崩溃。
忘记释放使用malloc分配的内存，导致内存泄漏。

calloc

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int n = 5;

    arr = (int*)calloc(n, sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // 初始化为0
    }
    printf("\n");

    free(arr);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

易错点：

忘记检查calloc返回值是否为NULL。
忘记释放使用calloc分配的内存，导致内存泄漏。

realloc

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int n = 5;

    arr = (int*)malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    n = 10;
    arr = (int*)realloc(arr, n * sizeof(int));
    if (arr == NULL) {
        printf("Memory reallocation failed\n");
        return 1;
    }

    for (int i = 5; i < n; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

易错点：

忘记检查realloc返回值是否为NULL。
直接将realloc的返回值赋给原指针，如果realloc失败，原指针会丢失，导致内存泄漏。正确的方法是使用一个临时指针来接收realloc的返回值。

free

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = (int*)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // 使用内存
    free(arr);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16