C语言中动态的申请二(三)及多维数组的使用方法及释放方法

最新推荐文章于 2022-09-06 12:56:00 发布
最新推荐文章于 2022-09-06 12:56:00 发布
阅读量845 收藏
点赞数 1
分类专栏： C++语言 VC++ C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010258235/article/details/27660563
版权
VC++ 同时被 3 个专栏收录
134 篇文章 0 订阅
订阅专栏
C语言
80 篇文章 5 订阅
订阅专栏
C++语言
73 篇文章 1 订阅
订阅专栏

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//动态申请二维数组  
template <typename T>  
T** malloc_Array2D(unsigned short row, unsigned short col)  
{  
    int size = sizeof(T);  
    int point_size = sizeof(T*);  
    //先申请内存，其中point_size * row表示存放row个行指针  
    T **arr = (T **) malloc(point_size * row + size * row * col);  
    if (arr != NULL)  
    {     
        memset(arr, 0, point_size * row + size * row * col);  
        T *head = (T*)((int)arr + point_size * row);  
        while (row--)  
            arr[row] = (T*)((int)head + row * col * size);  
    }  
    return (T**)arr;  
}  
//释放二维数组  
void free_Aarray2D(void **arr)  
{  
    if (arr != 0)  

        free(arr);  

arr = NULL;

}  
//定义滤波器信息结构体
//typedef struct _ArrayFilterMsg
struct _ArrayFilterMsg
{
int  m_nFilterNum;            //滤波点数
int  m_nCounter;               //滤波累加计数器
int  m_nFilterDataNum;         //滤波数组的数据量
};
//定义滤波器信息对象
struct _ArrayFilterMsg  m_ArrayData;
double *m_dpFilterArray;        //滤波数组
double **m_dpFilterArrayData;    //滤波数组中数据存储
double *m_dpFilterArraySum;      //滤波数组中数据累加和存储
void InitFilter(/*要初始化的结构体*/_ArrayFilterMsg m_ArrayData,/*滤波点数*/unsigned short nFilterNum, /*滤波计数器*/unsigned short nCounter, /*滤波数组元素数*/unsigned short nFilterDataNum)
{
m_ArrayData.m_nFilterNum = nFilterNum;
m_ArrayData.m_nCounter = 0;
m_ArrayData.m_nFilterDataNum = nFilterDataNum;
//m_ArrayData.m_dpFilterArray = (double*)malloc((m_ArrayData.m_nFilterDataNum)*sizeof(double));
//m_ArrayData.m_dpFilterArrayData = malloc_Array2D<double>(m_ArrayData.m_nFilterNum, m_ArrayData.m_nFilterDataNum);
m_dpFilterArrayData = malloc_Array2D<double>(m_ArrayData.m_nFilterNum, m_ArrayData.m_nFilterDataNum);
m_ArrayData.m_dpFilterArraySum = (double*)malloc((m_ArrayData.m_nFilterDataNum)*sizeof(double));
}
void FreeFilter(/*要初始化的结构体*/_ArrayFilterMsg m_ArrayData)
{
//free_Aarray2D((void **)m_ArrayData.m_dpFilterArrayData);

free_Aarray2D((void **)m_dpFilterArrayData);

m_dpFilterArrayData = NULL;

delete m_ArrayData.m_dpFilterArraySum;

m_ArrayData.m_dpFilterArraySum = NULL;

}
void FilterArray(double*pData)
{
#if 0
/******************************************滤波开始******************************************/
//对256道数据进行10点滤波
if(m_ArrayData.m_nCounter == m_ArrayData.m_nFilterNum)
{
m_ArrayData.m_nCounter = 0
}
//获取每一包数据的计数率
for(m_Logi = 0; m_Logi<m_ArrayData.m_nFilterDataNum;m_Logi++)
{
m_ArrayData.m_dpFilterArrayData[m_ArrayData.m_nCounter][m_Logi] = pData[m_Logi];
}
//计算指定滤波点数的数据累加和
for(m_Logi = 0; m_Logi<m_ArrayData.m_nFilterNum;m_Logi++)
{
for(int i = 0; i<m_ArrayData.m_nFilterDataNum;i++)
{
m_ArrayData.m_dpFilterArraySum[i] += m_ArrayData.m_dpFilterArrayData[m_Logi][i];
}
}
for(m_Logi = 0; m_Logi<m_ArrayData.m_nFilterDataNum;m_Logi++)
{
pData[m_Logi] = m_ArrayData.m_dpFilterArraySum[m_Logi] / m_ArrayData.m_nFilterNum;  //得到滤波后的计数率值
}
m_ArrayData.m_nCounter++;
#endif
/******************************************滤波结束******************************************/
}




int main(int argc, char* argv[])
{
#if 0
printf("  C语言中动态的申请二维数组 malloc free\n");    
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  


     printf("请输入行列(页)(以空格分开): ");  
    int nRow, nCol, nPage;  
    scanf("%d %d %d", &nRow, &nCol, &nPage);   
 
/***********************************************************演示动态开辟1开始****************************************/  
    //动态申请连续的二维数组  
    //int **p = malloc_Array2D<int>(nRow, nCol);  
InitFilter(/*要初始化的结构体*/ m_ArrayData,/*滤波点数*/ 10, /*滤波计数器*/0, /*滤波数组元素数*/256);
  
    //为二维数组赋值     
    int i, j;     
    for (i = 0; i < nRow; i++)  
{
        for (j = 0; j < nCol; j++)  
{
            //p[i][j] = i + j;  
//m_ArrayData.m_dpFilterArrayData[i][j] = i +j;
m_dpFilterArrayData[i][j] = i +j;
}
}
  
    //输出二维数组      
    for (i = 0; i < nRow; i++)  
    {  
        for (j = 0; j < nCol; j++)  
{
            //printf("%4d ", p[i][j]);  
//printf("%.1f ",m_ArrayData.m_dpFilterArrayData[i][j]); 
printf("%.1f ",m_dpFilterArrayData[i][j]); 
}
putchar('\n'); 
    }  
  
   // free_Aarray2D((void**)p); 


FreeFilter(/*要初始化的结构体*/ m_ArrayData);
/***********************************************************演示动态开辟1结束****************************************/  
#endif

return 0;

}




#if 0
//如果要给二维数组(m*n)分配空间，代码可以写成下面：


//char **a;
float **a;
void Init2Array(/*行*/int m, /*列*/int n)
{
// 先分配m个指针单元，注意是指针单元
// 所以每个单元的大小是sizeof(char *)
int i;
a = (float **) malloc(m * sizeof(float * ));
// 再分配n个字符单元，
// 上面的m个指针单元指向这n个字符单元首地址
for(i = 0; i < m; i++)
a[i] = (float * )malloc(n * sizeof(float ));

}


//（注意红色部分）
void Free2Array(/*行*/int m)
{
//释放应该是：
int i;
for(i=0;i<m;i++)
free((void *)a[i]);
free((void *)a);

a = NULL;
}


#endif

int main(int argc, char* argv[])
{
#if 0
printf("  C语言中动态的申请二维数组 malloc free\n");    
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  


     printf("请输入行列(页)(以空格分开): ");  
    int nRow, nCol, nPage;  
    scanf("%d %d %d", &nRow, &nCol, &nPage);   
 
#if 0

/***********************************************************演示动态开辟2开始****************************************/
printf("  C语言中动态的申请二维数组 malloc free\n");    
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  

    printf("请输入行列(以空格分开): ");  
    int nRow, nCol, nPage;  
    scanf("%d %d %d", &nRow, &nCol, &nPage);  
//char **a;

        //创建二维数组
Init2Array(/*行*/nRow, /*列*/nCol);
//为二维数组赋值     
    int  j, i;     
    for (i = 0; i < nRow; i++)  
{
        for (j = 0; j < nCol; j++)  
{
            //p[i][j] = i + j;  
//m_ArrayData.m_dpFilterArrayData[i][j] = i +j;
a[i][j] = i +j;
}
}

    //输出二维数组      
    for (i = 0; i < nRow; i++)  
    {  
        for (j = 0; j < nCol; j++)  
{
            //printf("%4d ", p[i][j]);  
//printf("%.1f ",m_ArrayData.m_dpFilterArrayData[i][j]); 
printf("%.1f ",a[i][j]); 
}
putchar('\n'); 
    }  
 //释放二维数组
Free2Array(nRow);
/***********************************************************演示动态开辟2结束****************************************/  
#endif

return 0;

}





#if 1
//如果为三维数组(m*n*p)分配空间呢，应该是：
float ***a;
void Init3Array(/*页*/int nPage,/*行*/int nRow, /*列*/int nCol )
{
int  i, j;
a = (float ***) malloc(nPage * sizeof(float ** ));
for(i = 0; i < nPage; ++i)
a[i] = (float **) malloc(nRow * sizeof(float * ));


for(i = 0; i < nPage; ++i)
for(j = 0; j < nRow; ++j)
a[i][j] = (float * )malloc(nCol * sizeof(float ));
}
//释放代码为逆过程，具体代码为：
void Free3Array(/*页*/int nPage,/*行*/int nRow)
{
int i,j;
for(i = 0; i < nPage; ++i)
for(j = 0; j < nRow; ++j)
free((void *)a[i][j]);   
for(i = 0; i < nPage; ++i)
free((void *)a[i]);

free((void *)a);

a = NULL;

}

int main(int argc, char* argv[])
{

/***********************************************************演示动态开辟3开始****************************************/ 


#if 1
printf("  C语言中动态的申请二(三)维数组 malloc free\n");    
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  

printf("请输入行列(以空格分开): nPage(页),nRow(行), nCol(列)");  
    int nPage,nRow, nCol;  
    scanf("%d %d %d", &nPage,&nRow, &nCol); 

       //创建三维数组
Init3Array(nPage,nRow,nCol);
//为三维数组赋值     
    int  j, i,k;     
    for (i = 0; i < nPage; i++)  
{
        for (j = 0; j < nRow; j++)  
{
for(k = 0; k < nCol; k++)
{
//p[i][j] = i + j;  
//m_ArrayData.m_dpFilterArrayData[i][j] = i +j;
a[i][j][k] = i +j + k;
}
}
}

    //输出三维数组      
    for (i = 0; i <nPage ; i++)  
    {  
        for (j = 0; j <nRow ; j++)  
{
for(k = 0; k <nCol ; k++)
{
//printf("%4d ", p[i][j]);  
//printf("%.1f ",m_ArrayData.m_dpFilterArrayData[i][j]); 
printf("%.1f ",a[i][j][k]); 
}
putchar('\n');
}
putchar('\n'); 
    }  

      //释放三维数组
Free3Array(nPage,nRow);
#endif
/***********************************************************演示动态开辟3结束****************************************/  
return 0;

}


#endif




#if TestMallocArray4
//动态申请二维数组  
template <typename T>  
T** malloc_Array2D(unsigned short row, unsigned short col)  
{  
    int size = sizeof(T);  
    int point_size = sizeof(T*);  
    //先申请内存，其中point_size * row表示存放row个行指针  
    T **arr = (T **) malloc(point_size * row + size * row * col);  
    if (arr != NULL)  
    {     
        memset(arr, 0, point_size * row + size * row * col);  
        T *head = (T*)((int)arr + point_size * row);  
        while (row--)  
            arr[row] = (T*)((int)head + row * col * size);  
    }  
    return (T**)arr;  
}  
//释放二维数组  
void free_Aarray2D(void **arr)  
{  
    if (arr != 0)  
        free(arr);  
arr = NULL;
}  
//定义滤波器信息结构体
//typedef struct _ArrayFilterMsg
struct _ArrayFilterMsg
{
int  m_nFilterNum;            //滤波点数
int  m_nCounter;               //滤波累加计数器
int  m_nFilterDataNum;         //滤波数组的数据量
double *m_dpFilterArray;        //滤波数组
double **m_dpFilterArrayData;    //滤波数组中数据存储
double *m_dpFilterArraySum;      //滤波数组中数据累加和存储
};
//定义滤波器信息对象
struct _ArrayFilterMsg  m_ArrayData;
void InitFilter(/*要初始化的结构体*/_ArrayFilterMsg *m_ArrayData,/*滤波点数*/unsigned short nFilterNum, /*滤波计数器*/unsigned short nCounter, /*滤波数组元素数*/unsigned short nFilterDataNum)
{
m_ArrayData->m_nFilterNum = nFilterNum;
m_ArrayData->m_nCounter = 0;
m_ArrayData->m_nFilterDataNum = nFilterDataNum;

m_ArrayData->m_dpFilterArray = (double*)malloc((m_ArrayData->m_nFilterDataNum)*sizeof(double));
m_ArrayData->m_dpFilterArrayData = malloc_Array2D<double>(m_ArrayData->m_nFilterNum, m_ArrayData->m_nFilterDataNum);
}
void FreeFilter(/*要初始化的结构体*/_ArrayFilterMsg *m_ArrayData)
{
free_Aarray2D((void **)m_ArrayData->m_dpFilterArrayData);
m_ArrayData->m_dpFilterArrayData= NULL;
delete m_ArrayData->m_dpFilterArraySum;
m_ArrayData->m_dpFilterArraySum = NULL;
}
#endif


#if TestMallocArray4
printf("  C语言中动态的申请二维数组 malloc free\n");    
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  

    printf("请输入行列(以空格分开): ");  
    int nRow, nCol;  
    scanf("%d %d", &nRow, &nCol);  
/***********************************************************演示动态开辟4开始****************************************/ 
//动态申请连续的二维数组  
    //int **p = malloc_Array2D<int>(nRow, nCol);  
InitFilter(/*要初始化的结构体*/ &m_ArrayData,/*滤波点数*/ nRow, /*滤波计数器*/0, /*滤波数组元素数*/nCol);

    //为二维数组赋值     
    int i, j;     
    for (i = 0; i < nRow; i++)  
{
        for (j = 0; j < nCol; j++)  
{
m_ArrayData.m_dpFilterArrayData[i][j] = i +j;
}
}

    //输出二维数组      
    for (i = 0; i < nRow; i++)  
    {  
        for (j = 0; j < nCol; j++)  
{
printf("%.1f ",m_ArrayData.m_dpFilterArrayData[i][j]); 
}
putchar('\n'); 
    }  

FreeFilter(/*要初始化的结构体*/ &m_ArrayData);
/***********************************************************演示动态开辟4结束****************************************/  
#endif

An_angel_of_joy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言中多维数组的内存分配和释放(malloc与free)的方法
01-01
如果要给二维数组(m*n)分配空间，代码可以写成下面： 代码如下:char **a, i; // 先分配m个指针单元，注意是指针单元 // 所以每个单元的大小是sizeof(char *) a = (char **) malloc(m * sizeof(char * )); // 再分配n...
[C/C++]二维数组的创建与释放
culeworks
02-17 387
要创建一个m*n的二维数组arr，方法如下： C: int** arr=(int **)malloc(sizeof(int *)*m); for (i=0; i<m; i++){ arr[i]=(int *)malloc(sizeof(int) * n); } C++: int ** arr=new int* [m]; for (i=0; i<m; i++){ 　　arr[i]...
二维数组的动态创建和释放
这是一个c++热爱者的博客哟
07-31 1241
如果是采取一个一个申请一维数组，那无法保证这些一维数组所形成的二维数组行指针内存连续。//运行以后，指针p非但不会消亡，其值还会保持不变，并不会变为null。此时使用if(指针!//假设p是代码块内声明的局部指针变量，在代码块执行完毕退出时，p自动消亡，但p指向的大小为8、类型为int的内存空间不会释放掉。解决方法指针被free或者delete后，一定要置为null，没有置为null的指针常称为”野指针“。//代码退出后，程序无法再通过指针p释放所申请的动态内存，这块内存已经“泄露——————内存泄漏。..
c语言二维动态数组创建及释放,c++创建二维动态数组与内存释放问题
weixin_28932927的博客
05-21 383
如下：#include #include using namespace std;int main(){cout << "create dynamic two-dimension array..." << endl;int sizeX = 5;int sizeY = 8;// 申请double** array = new double*[sizeX];for (int i ...
C语言动态开辟多维数组空间
最新发布
zzw3354353337的博客
09-06 2389
在一些特定的程序中，我们常常无法预测数组的大小。如果我们自己将值分配给数组，那么它在执行期间无法更改。这会产生问题，要么数组的内存变低，要么数组占用更少的空间浪费内存，因此为避免这种情况，建议动态分配数组。
C语言之动态一/二/三维数组的申请与释放
十三阿哥的博客
03-01 2177
注意： （0） 讲解C语言中的动态数组的申请以及释放（一维/二维/三维）； （1）需要你对C语言中的至少是一维数组非常熟悉， 不流于表面，否则可能稍有难度； （2）打印使用了C++中的std::cout语法, 主要是方便; (读者不要纠结)； （3）每种申请都配合了一张图解， 便于理解， 应该可以看懂； （4）注意一点: C语言的中指针变量类型占用4个字节； 1. 动态一维数组的申请与释放 void test0() { int array[6] = { 1, 2, 6, 7, 10, 12 }; //
C语言中动态数组的构建.pdf
09-19
这意味着在构建多维数组时，需要先申请较小的数组，然后逐步扩展到更大的维度。 使用动态数组时，必须注意内存管理。如果忘记释放内存，会导致内存泄漏，影响程序性能和稳定性。同时，不能对同一块内存使用`free`两...
C语言函数数组定义应用
06-18
### C语言函数数组定义应用 ...本文介绍了C语言中数组的相关概念，包括静态数组的定义、动态内存分配、多维数组以及具体的代码实现。通过这些知识点的学习，读者可以更加熟练地使用C语言处理各种数组相关的编程任务。
动态数组 VC.docx
07-07
在C语言中，构建一维动态数组需要一维指针，而构建二维、三维等更高维度的数组则需要相应数量的指针层次。 动态数组的创建和使用虽然比静态数组复杂，但它提供了更大的便利性。例如，`malloc`函数用于申请指定大小...
C语言程序设计试题集及其答案.pdf
09-30
- 动态内存分配：使用malloc()、calloc()、realloc()和free()函数进行内存的动态申请和释放。 - 内存对齐：了解编译器如何对齐内存，避免性能损失和潜在错误。 8. **文件操作**： - 打开与关闭文件：使用fopen()...
c语言中内存的动态分配与释放（多维动态数组构建）
Embedded engineer
02-29 525
一. 静态数组与动态数组 静态数组比较常见，数组长度预先定义好，在整个程序中，一旦给定大小后就无法再改变长度，静态数组自己自动负责释放占用的内存。 动态数组长度可以随程序的需要而重新指定大小。动态数组由内存分配函数(malloc)从堆（heap）上分配存储空间，只有当程序执行了分配函数后，才为其分配内存，同时由程序员自己负责释放分配的内存（free）。二. 为什么要使用动态数...
C语言中多维数组的内存分配和释放（malloc与free）
热门推荐
schoolers的专栏
10-16 1万+
写代码的时候会碰到多维数组的内存分配和释放问题，在分配和释放过程中很容易出现错误。下面贴上一些示例代码，以供参考。   如果要给二维数组(m*n)分配空间，代码可以写成下面： char **a, i; // 先分配m个指针单元，注意是指针单元 // 所以每个单元的大小是sizeof(char *) a = (char **)malloc(m * sizeof(char
C语言动态申请二维数组【用new函数】
Be Like
09-28 7691
#include<stdio.h>const int m = 10; int i, j;int main() { //动态申请二维数组 //先声明一个指向指针的指针，然后赋予一个指针数组 int **f = new int *[m]; for(i = 0; i < m; i++) f[i] = new int [4]; for(i = 0; i
C 二维数组的动态申请
yogach的博客
05-09 754
二维数组实际上可以看做是每个数组元素的数据类型为一维数组的数组。同时二维数组的内存空间中存储也是连续的。 如下图所示： 所以我们在进行动态申请需要注意的就是，保留二维数组数据存储区域是连续的特性。 代码如下： #include <stdio.h> #include <malloc.h> int** malloc2d(int row, int col) { int** ret = NULL; if((row > 0)&&(c
C语言中如何为数组申请动态分配内存？
qq_52051345的博客
12-04 1万+
为一维数组申请动态分配内存 #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; int main() { int n; int i; int *a; scanf(&amp;quot;%d&amp;quot;, &amp;amp;amp;n); a = (int*)malloc(sizeof(int)*n);//为数组
动态分配多维数组和释放其内存
过路人
11-23 671
/*动态构建三维数组内存分配函数*/ /* * pArr: 指向三维数组首地址 * x: 三维数组第一维元素个数 * y: 三维数组第二维元素个数 * z: 三维数组第三维元素个数 */ void Create3DActiveArray(int ***pArr, int x, int y, int z) { int i, j, k; pArr = (int ***)mal
c语言动态申请函数,C语言用malloc函数申请二维动态数组
weixin_32136817的博客
05-20 225
C语言在程序运行中动态的申请及释放内存十分方便，一维数组的申请及释放比较简单。Sample one#include int main(){char * p=(char *)malloc(sizeof(char)*5);//申请包含5个字符型的数组free(p);return 0;}是否申请二维动态内存也如此简单呢？答案是否定的。申请二维数组有一下几种方法Sample two/* 申请一个5行3列的...
动态规划——DP数组
weixin_30466421的博客
04-09 1244
动态规划是通过找当前项和前一或几项或后一或几项的关系,从而对一个数组多次利用达到减少复杂度。 1.当一串数可以不限次利用时，采用顺序的方式循环：for(j=0;j<=max_n;j++)（一维数组）或者加一个for(k=0;k*A[i]<=j;k++)(二维数组) 2.当一串数的使用次数有限时用for(k=0;k*A[i]<=j&&k<=B[i];k++...
"Visual C 6.0环境下的二级C语言程序设计考试大纲及要求
数组的使用和操作（1）一维数组和多维数组的定义和使用。（2）数组元素的引用和赋值。（3）数组作为函数的参数。（4）字符串数组的定义和处理。8. 指针的使用（1）指针变量的定义和初始化。（2）指针变量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值