C语言动态内存开辟
malloc函数
malloc函数包含再#include<stdlib.h>头文件中
void* malloc (size_t size);
这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针。
- 如果开辟成功，则返回⼀个指向开辟好空间的指针。
2.如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查。
3.返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定。
4.如果参数 size 为0，malloc的⾏为是标准是未定义的，取决于编译器。
free函数
free函数包含再#include<stdlib.h>头文件中
函数free专⻔是⽤来做动态内存的释放和回收的
如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的。
如果参数 ptr 是NULL指针，则函数什么事都不做。
#include<stdio.h>
#include<stdlib.h>
int main()
{
int num=0;
scanf("%d",&num);
int* arr=(int*)malloc(sizeof(int)*num);
if(arr!=NULL)
{
for(int i=0;i<num;i++)
{
printf("%d ",arr[i]);
}
}
free(arr);
arr=NULL;
return 0;
}
malloc函数开辟出来的数据是随机值。
动态开辟的空间⼀定要释放，并且正确释放。
calloc函数
void* calloc (size_t num, size_t size);
> calloc函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0
> 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为0
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
int i = 0;
for(i=0; i<10; i++)
{
printf("%d ", *(p+i));
}
}
free(p);
p = NULL;
return 0;
}
动态开辟的空间⼀定要释放，并且正确释放。
realloc函数
有时会我们发现过去申请的空间太⼩了，有时候我们⼜会觉得申请的空间过⼤了，那为了合理的时候内存，我们⼀定会对内存的⼤⼩做灵活的调整。那 realloc 函数就可以做到对动态开辟内存⼤⼩的调整。
void* realloc (void* ptr, size_t size);
1.ptr 是要调整的内存地址
2.size 调整之后新⼤⼩
3.返回值为调整之后的内存起始位置。
4.这个函数调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到 新 的空间。
5.realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有⾜够⼤的空间
情况2：原有空间之后没有⾜够⼤的空间
当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发⽣变化。
当是情况2的时候，原有空间之后没有⾜够多的空间时，扩展的⽅法是：在堆空间上另找⼀个合适⼤⼩
的连续空间来使⽤。这样函数返回的是⼀个新的内存地址。
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p = (int*)calloc(10, sizeof(int));
int *pp=realloc(p,sizeof(int)*100);
if(pp!=NULL)
{
p=pp;
}
free(p);
p = NULL;
return 0;
}
二维数组的动态内存开辟
int main()
{
int row=3,col=3;
int** arr=(int**)malloc(sizeof(int*)*row);//给行分配空间
for(int i=0;i<col;i++)
{
arr[i]=(int*)malloc(sizeof(int)*col);//给列分配空间
}
for(int i=0;i<row;i++)
{
for(int j=0;j<col;j++)
{
arr[i][j]=i+j;//给数组赋值
}
}
for(int i=0;i<row;i++)
{
for(int j=0;j<col;j++)
{
printf("%d ",arr[i][j]);//打印数组
}
printf("\n");
}
for(int i=0;i<col;i++)
{
free(arr[i]);//释放列
}
free(arr);//释放行
return 0;
}
int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes){
int m = matrixSize;
int n = matrixColSize[0];
int i, j;
int **res = (int**)malloc(sizeof(int*) * n);
*returnColumnSizes = (int*)malloc(sizeof(int) * n);
for (i = 0; i < n; i++) {
res[i] = (int*)malloc(sizeof(int) * m);
(*returnColumnSizes)[i] = m;
for (j = 0; j < m; j++)
{
res[i][j] = matrix[j][i];
}
}
*returnSize = n;
return res;
}
int main() {
// 定义矩阵大小和列大小
int matrixSize = 3; // 假设矩阵有3行
int matrixColSize = 3; // 假设矩阵有3列
int returnSize = 0; // 用于接收转置后矩阵的行数
int* returnColumnSizes = NULL; // 用于接收转置后矩阵每行的列数数组
// 创建原始矩阵
int** matrix = (int**)malloc(sizeof(int*) * matrixSize);
for (int i = 0; i < matrixSize; i++) {
matrix[i] = (int*)malloc(sizeof(int) * matrixColSize);
}
// 填充矩阵数据
for (int i = 0; i < matrixSize; i++) {
for (int j = 0; j < matrixColSize; j++) {
matrix[i][j] = i * matrixColSize + j; // 例如，用行和列的乘积加和来填充
}
}
// 调用 transpose 函数
int** transposedMatrix = transpose(matrix, matrixSize, &matrixColSize, &returnSize, &returnColumnSizes);
// 打印转置后的矩阵
printf("Transposed Matrix:\n");
for (int i = 0; i < returnSize; i++) {
for (int j = 0; j < returnColumnSizes[i]; j++) {
printf("%d ", transposedMatrix[i][j]);
}
printf("\n");
}
// 释放内存
for (int i = 0; i < matrixSize; i++) {
free(matrix[i]);
}
free(matrix);
for (int i = 0; i < returnSize; i++) {
free(transposedMatrix[i]);
}
free(transposedMatrix);
free(returnColumnSizes);
return 0;
}
原文地址：https://blog.csdn.net/2403_82759827/article/details/142904873
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！