[C语言]动态内存管理与柔性数组

EnticE152

已于 2023-09-26 09:49:40 修改

阅读量459

点赞数 17

文章标签： c语言 c++

于 2022-10-26 16:33:09 首次发布

本文链接：https://blog.csdn.net/qq_66767938/article/details/127532663

版权

动态内存管理与柔性数组：：

动态内存：

定义数组开辟内存的缺陷：

1.开辟空间的大小固定.

2.数组在定义的时候，必须指定数组的长度.

动态内存开辟的原因：

1.程序不知道要使用多少对象.例如：容器类

2.程序不知道所需对象的准确类型.

3.程序需要在多个对象间共享数据.例如：智能指针

动态内存函数的介绍

malloc

int main()
{
	//动态内存开辟
	//malloc申请的空间在堆区申请
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//没有free并不是说内存空间就不回收了 当程序退出的时候 系统会自动回收内存空间的
	free(p);
	p = NULL;
	return 0;
}

free

calloc

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

realloc

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}
	//扩容
	int* ptr = (int*)realloc(p, 80);
	if (ptr == NULL)
	{
		perror("realloc fail");
		exit(-1);
	}
	p = ptr;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

常见的动态内存错误

1.对空指针的解引用操作

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	*p = 20;//如果p的值为空指针 就会有问题
	free(p);
	p = NULL;
	return 0;
}

2.对动态开辟空间的越界访问

#include<stdlib.h>
#include<errno.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;
	}
	free(p);
	p = NULL;
	return 0;
}

3.对非动态开辟空间的free释放

int main()
{
	int a = 10;
	int* p = &a;
	free(p);
	p = NULL;
}

4.使用free释放动态开辟内存的一部分

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	free(p);
	p = NULL;
	return 0;
}

5.对同一块动态内存多次释放

#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(40);
	free(p);
	free(p);
	return 0;
}

6.动态内存忘记释放(内存泄漏)

//代码1
void test()
{
	int* p = (int*)malloc(100);
	int flag = 0;
	scanf("%d", &flag);
	if (flag == 5)
		return;
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}
//代码2
int* test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return p;
	}
	return p;
}
int main()
{
	int* ret = test();
	//忘记释放
	return 0;
}

动态内存相关笔试题

笔试题1

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

笔试题2

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

笔试题3

void GetMemory(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

笔试题4

void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

1.栈区(stack)：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

2.堆区(heap)：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

3.数据段(静态区)：存放全局变量、静态数据程序结束后由系统释放。

4代码段：存放函数体(类成员函数和全局函数)的二进制代码。

柔性数组：

柔性数组的定义：

结构体中最后一个元素允许是未知大小的数组，这就是柔性数组成员，柔性数组就是结构体中的一

个成员变量.

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

柔性数组的特点

1.结构中的柔性数组成员前面必须至少一个其他成员.

2.sizeof返回的这种结构大小不包括柔性数组的内存.

3.包含柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大

小，以适应柔性数组的预期大小.

柔性数组的使用

struct S
{
	int n;
	int arr[];
};
int main()
{
	//struct S s;//柔性数组不能这么创建变量 s只占4byte 没有包括柔性数组成员的大小
	//正确写法
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
	if (ps == NULL)
	{
        perror("malloc fail");
		exit(-1);
	}
	ps->n = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 80);
	if (ptr != NULL)
	{
		ps = ptr;
	}
	free(ps);
	ps = NULL;
	return 0;
}

柔性数组的优势

第一个好处是：方便内存释放

如果我们的代码是在一个给别人用的函数中，你在里面做了两次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体的成员也需要free，所以你不能指望用户来发现这个事情，所以，如果我们把结构体的内存以及其他成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是： 这样有利于访问速度

连续的内存有益于提高访问速度，也有益于减少内存碎片，防止内存泄漏。

C语言编程训练：

1.BC65-箭形图案

int main()
{
	int n = 0;
	while (scanf("%d", &n) == 1)
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n - i; j++)
			{
				printf("  ");
			}
			for (int j = 0; j <= i; j++)
			{
				printf("*");
			}
			printf("\n");
		}
		for (int i = 0; i < n + 1; i++)
		{
			for (int j = 0; j < i; j++)
			{
				printf("  ");
			}
			for (int j = 0; j < n + 1 - i; j++)
			{
				printf("*");
			}
			printf("\n");
		}
	}
	return 0;
}

2.BC69—空心正方形图案

int main()
{
    int n = 0;
    while (scanf("%d", &n) == 1)
    {
        int i = 0;
        int j = 0;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (i == 0 || i == n - 1 || j == 0 || j == n - 1)
                    printf("* ");
                else
                    printf("  ");
            }
            printf("\n");
        }
    }
    return 0;
}

3.BC76-公务员面试

#include <stdio.h>
int main()
{
    int score = 0;
    int n = 0;
    int max = 0;
    int min = 100;
    int sum = 0;
    while (scanf("%d", &score) == 1)
    {
        n++;
        if (score > max)
            max = score;
        if (score < min)
            min = score;
        sum += score;
        if (n == 7)
        {
            printf("%.2lf\n", (sum - max - min) / 5.0);
            n = 0;
            max = 0;
            min = 100;
            sum = 0;
        }
    }
    return 0;
}

4.找单身狗

//思路:先分组再异或
	 //分组:
	 //1.所有数字异或
	 //2.找出异或的结果中哪一位为1 - n
	 //以第n位为1分一组 第n位为0分一组
void find_singal_dog(int arr[], int sz, int* pd1, int* pd2)
{
	int i = 0;
	int ret = 0;
	for (i = 0; i < sz; i++)
	{
		ret ^= arr[i];
	}
	//计算二进制中最右边的第几位是1
	int pos = 0;
	for (pos = 0; pos < 32; pos++)
	{
		if (((ret >> pos) & 1) == 1)
		{
			break;
		}
	}
	for (i = 0; i < sz; i++)
	{
		if ((arr[i] >> pos) & 1 == 1)
		{
			*pd1 ^= arr[i];
		}
		else
		{
			*pd2 ^= arr[i];
		}
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int dog1 = 0;
	int dog2 = 0;
	find_singal_dog(arr, sz, dog1, dog2);
	printf("%d %d\n", dog1, dog2);
	return 0;
}

5.只出现一次的数字

int singleNumber(int* nums, int numsSize)
{
    int single = 0;
    for(int i = 0;i<numsSize;i++)
    {
        single ^= nums[i];
    }
    return single;
}

6.只出现一次的数字III

//方法一:
int* singleNumber(int* nums, int numsSize, int* returnSize)
{
    *returnSize = 0;
    int* tmp = (int*)malloc(sizeof(int) * numsSize);
    if(tmp == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    for(int i = 0;i < numsSize;i++)
    {
        int count = 0;
        for(int j = 0;j < numsSize;j++)
        {
            if(nums[i] == nums[j])
            {
                count++;
            }
        }
        if(count == 1)
        {
            tmp[*returnSize] = nums[i];
            (*returnSize)++;
        }
    }
    return tmp;
}
//方法二: