在C/C++计算机语言中动态分配二维数组

最新推荐文章于 2023-08-18 21:41:23 发布
最新推荐文章于 2023-08-18 21:41:23 发布
阅读量965 收藏 1
点赞数 1
文章标签： 编程 二维数组 内存泄露 数据 指针

如何在C/C++中动态分配二维数组

在C/C++中动态分配二维数组可以先申请一维的指针数组，然后该数组中的每个指针再申请数组，这样就相当于二维数组了，但是这种方法会导致每行可能不相邻，从而访问效率比较低。如何申请连续的二维数组了？本文将分别三个方面讲解：

一．动态申请列大小固定的二维数组

二．C语言中动态申请连续的二维数组

三．C++语言中动态申请连续的二维数组

 

一．动态申请列大小固定的二维数组

首先如果二维数组的列大小固定，那么很简单，可以用申请一维数数组再其指针强制转化成为二维数组指针即可。详见代码：

[cpp] view plain copy print ?
  1. //列大小固定的二维数组可以申请一维数据并将指针强转成二维数组  
  2. #include <stdio.h>  
  3. int main()  
  4. {  
  5.     printf("  列大小固定的二维数组可以申请一维数据并将指针强转成二维数组\n");    
  6.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");    
  7.   
  8.     //列值固定  
  9.     const int MAXCOL = 3;  
  10.   
  11.     int nRow;  
  12.     printf("请输入二维数组的行数(列值固定为%d): ", MAXCOL);  
  13.     scanf("%d", &nRow);  
  14.   
  15.     //申请一维数据并将其转成二维数组指针  
  16.     int *pp_arr = new int[nRow * MAXCOL];  
  17.     int (*p)[MAXCOL] = (int(*)[MAXCOL])pp_arr;  
  18.   
  19.     //为二维数组赋值  
  20.     int i, j;  
  21.     for (i = 0; i < nRow; i++)  
  22.         for (j = 0; j < MAXCOL; j++)  
  23.             p[i][j] = i + j;  
  24.       
  25.     //输出二维数组  
  26.     for (i = 0; i < nRow; i++)  
  27.     {  
  28.         for (j = 0; j < MAXCOL; j++)  
  29.             printf("%5d", p[i][j]);  
  30.         putchar('\n');  
  31.     }  
  32.   
  33.     //释放资源  
  34.     delete[] pp_arr;  
  35.     return 0;  
  36. }  
//列大小固定的二维数组可以申请一维数据并将指针强转成二维数组
#include <stdio.h>
int main()
{
	printf("  列大小固定的二维数组可以申请一维数据并将指针强转成二维数组\n");  
	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  

	//列值固定
	const int MAXCOL = 3;

	int nRow;
	printf("请输入二维数组的行数(列值固定为%d): ", MAXCOL);
	scanf("%d", &nRow);

	//申请一维数据并将其转成二维数组指针
	int *pp_arr = new int[nRow * MAXCOL];
	int (*p)[MAXCOL] = (int(*)[MAXCOL])pp_arr;

	//为二维数组赋值
	int i, j;
	for (i = 0; i < nRow; i++)
		for (j = 0; j < MAXCOL; j++)
			p[i][j] = i + j;
	
	//输出二维数组
	for (i = 0; i < nRow; i++)
	{
		for (j = 0; j < MAXCOL; j++)
			printf("%5d", p[i][j]);
		putchar('\n');
	}

	//释放资源
	delete[] pp_arr;
	return 0;
}

运行结果如下所示：

 

二．C语言中动态申请连续的二维数组

上面的方法虽然方便，但必须要求列的大小固定。下面先来试下在C语言中如何动态申请连续的二维数组。可以采用多申请一些指针，然后这一些指针分别指向后面数据区中对应的位置，如一个3*4的int类型数组，我们先申请大小为sizeof(int*) * 3 + 3 * 4 * sizeof(int)的一维数组设为arr。然后arr[0]存放指向arr + sizeof(int*) * 3这个位置的指针，arr[1]存放指向arr + sizeof(int*) * 3 + 4 * sizeof(int)这个位置的指针， arr[2]存放指向arr + sizeof(int*) * 3 + 2 * 4 * sizeof(int)这个位置的指针。下面用图展示指向的示意：

详细代码如下，由于指针操作有点小复杂，请读者耐心看：

[cpp] view plain copy print ?
  1. //C语言中动态的申请二维数组 malloc free  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <string.h>  
  5. //动态申请二维数组  
  6. template <typename T>  
  7. T** malloc_Array2D(int row, int col)  
  8. {  
  9.     int size = sizeof(T);  
  10.     int point_size = sizeof(T*);  
  11.     //先申请内存，其中point_size * row表示存放row个行指针  
  12.     T **arr = (T **) malloc(point_size * row + size * row * col);  
  13.     if (arr != NULL)  
  14.     {     
  15.         memset(arr, 0, point_size * row + size * row * col);  
  16.         T *head = (T*)((int)arr + point_size * row);  
  17.         while (row--)  
  18.             arr[row] = (T*)((int)head + row * col * size);  
  19.     }  
  20.     return (T**)arr;  
  21. }  
  22. //释放二维数组  
  23. void free_Aarray2D(void **arr)  
  24. {  
  25.     if (arr != NULL)  
  26.         free(arr);  
  27. }  
  28. int main()  
  29. {  
  30.     printf("  C语言中动态的申请二维数组 malloc free\n");    
  31.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
  32.   
  33.     printf("请输入行列(以空格分开): ");  
  34.     int nRow, nCol;  
  35.     scanf("%d %d", &nRow, &nCol);  
  36.   
  37.     //动态申请连续的二维数组  
  38.     int **p = malloc_Array2D<int>(nRow, nCol);  
  39.   
  40.     //为二维数组赋值     
  41.     int i, j;     
  42.     for (i = 0; i < nRow; i++)  
  43.         for (j = 0; j < nCol; j++)  
  44.             p[i][j] = i + j;  
  45.   
  46.     //输出二维数组      
  47.     for (i = 0; i < nRow; i++)  
  48.     {  
  49.         for (j = 0; j < nCol; j++)  
  50.             printf("%4d ", p[i][j]);  
  51.         putchar('\n');  
  52.     }  
  53.   
  54.     free_Aarray2D((void**)p);  
  55.     return 0;  
  56. }  
//C语言中动态的申请二维数组 malloc free
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//动态申请二维数组
template <typename T>
T** malloc_Array2D(int row, int 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 != NULL)
		free(arr);
}
int main()
{
	printf("  C语言中动态的申请二维数组 malloc free\n");  
	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

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

	//动态申请连续的二维数组
	int **p = malloc_Array2D<int>(nRow, nCol);

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

	//输出二维数组	
	for (i = 0; i < nRow; i++)
	{
		for (j = 0; j < nCol; j++)
			printf("%4d ", p[i][j]);
		putchar('\n');
	}

	free_Aarray2D((void**)p);
	return 0;
}

运行结果如下：

 

 

三．C++语言中动态申请连续的二维数组

可以看出我们已经成功实现了在C语言中动态申请连续的二维数组，如果上面的程序不使用int类型而使用string类这种类型，那会有什么后果了？肯定的说，由于没有调用构造函数和析构函数，程序绝对会造成内存泄露。因此要做下改进，下面给出在C++语言中动态申请连续的二维数组的代码，有些C++语法可能平时见得少，但其实这些语法在STL里面运用还是比较多的，有兴趣的童鞋应该掌握下。

[cpp] view plain copy print ?
  1. //C++语言中动态的申请二维数组 new delete  
  2. #include <new>  
  3. #include <cstdio>  
  4. #include <cstdlib>  
  5. #include <string>  
  6. using namespace std;  
  7. //动态申请二维数组  
  8. template <typename T>  
  9. T** new_Array2D(int row, int col)  
  10. {  
  11.     int size = sizeof(T);  
  12.     int point_size = sizeof(T*);  
  13.     //先申请内存，其中sizeof(T*) * row表示存放row个行指针  
  14.     T **arr = (T **) malloc(point_size * row + size * row * col);  
  15.     if (arr != NULL)  
  16.     {     
  17.         T *head = (T*)((int)arr + point_size * row);  
  18.         for (int i = 0; i < row; ++i)  
  19.         {  
  20.             arr[i] =  (T*)((int)head + i * col * size);  
  21.             for (int j = 0; j < col; ++j)  
  22.                 new (&arr[i][j]) T;  
  23.         }  
  24.     }  
  25.     return (T**)arr;  
  26. }  
  27. //释放二维数组  
  28. template <typename T>  
  29. void delete_Array2D(T **arr, int row, int col)  
  30. {  
  31.     for (int i = 0; i < row; ++i)  
  32.         for (int j = 0; j < col; ++j)  
  33.             arr[i][j].~T();  
  34.     if (arr != NULL)  
  35.         free((void**)arr);  
  36. }  
  37. int main()  
  38. {  
  39.     printf("  C++语言中动态的申请二维数组 new delete\n");    
  40.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
  41.   
  42.     printf("请输入行列(以空格分开): ");  
  43.     int nRow, nCol;  
  44.     scanf("%d %d", &nRow, &nCol);  
  45.   
  46.     //动态申请连续的二维数组  
  47.     string **p = new_Array2D<string>(nRow, nCol);  
  48.   
  49.     //为二维数组赋值  
  50.     int i, j;  
  51.     for (i = 0; i < nRow; i++)  
  52.         for (j = 0; j < nCol; j++)  
  53.         {  
  54.             char szTemp[30];  
  55.             sprintf(szTemp, "(第%d行,第%d列)", i, j);  
  56.             p[i][j] = szTemp;  
  57.         }  
  58.   
  59.     //输出二维数组      
  60.     for (i = 0; i < nRow; i++)  
  61.     {  
  62.         for (j = 0; j < nCol; j++)  
  63.             printf("%s ", p[i][j].c_str());  
  64.         putchar('\n');  
  65.     }  
  66.   
  67.     delete_Array2D<string>(p, nRow, nCol);  
  68.     return 0;  
  69. }  
//C++语言中动态的申请二维数组 new delete
#include <new>
#include <cstdio>
#include <cstdlib>
#include <string>
using namespace std;
//动态申请二维数组
template <typename T>
T** new_Array2D(int row, int col)
{
	int size = sizeof(T);
	int point_size = sizeof(T*);
	//先申请内存，其中sizeof(T*) * row表示存放row个行指针
	T **arr = (T **) malloc(point_size * row + size * row * col);
	if (arr != NULL)
	{	
		T *head = (T*)((int)arr + point_size * row);
		for (int i = 0; i < row; ++i)
		{
			arr[i] =  (T*)((int)head + i * col * size);
			for (int j = 0; j < col; ++j)
				new (&arr[i][j]) T;
		}
	}
	return (T**)arr;
}
//释放二维数组
template <typename T>
void delete_Array2D(T **arr, int row, int col)
{
	for (int i = 0; i < row; ++i)
		for (int j = 0; j < col; ++j)
			arr[i][j].~T();
	if (arr != NULL)
		free((void**)arr);
}
int main()
{
	printf("  C++语言中动态的申请二维数组 new delete\n");  
	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");

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

	//动态申请连续的二维数组
	string **p = new_Array2D<string>(nRow, nCol);

	//为二维数组赋值
	int i, j;
	for (i = 0; i < nRow; i++)
		for (j = 0; j < nCol; j++)
		{
			char szTemp[30];
			sprintf(szTemp, "(第%d行,第%d列)", i, j);
			p[i][j] = szTemp;
		}

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

	delete_Array2D<string>(p, nRow, nCol);
	return 0;
}

运行结果如下：

 

 

 

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7664479

如果觉得本文对您有帮助，请点击‘顶’支持一下，您的支持是我写作最大的动力，谢谢。



 

Gabanon
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何在C/C++中动态分配二维数组
huobengluantiao8
06-18 3462
如何在C/C++中动态分配二维数组 在C/C++中动态分配二维数组可以先申请一维的指针数组，然后该数组中的每个指针再申请数组，这样就相当于二维数组了，但是这种方法会导致每行可能不相邻，从而访问效率比较低。如何申请连续的二维数组了？本文将分别三个方面讲解： 一．动态申请列大小固定的二维数组 二．C语言中动态申请连续的二维数组 三．C++语言中动态申请连续的二维数组 一．动态申请列大小固定的二维数组...
C++动态分配二维数组
GVFDBDF的专栏
04-04 1483
1. 动态分配 动态分配就是在运行的时候进行内存的分配，在C++中，可以在栈上分配数组，这种情况下，必须指定数组的长度，长度不能是变量，必须是常量或者常量表达式（其原因在于静态分配在编译时需要知道数组的长度，而变量在编译时不知道大小，所以必须指定为常量） 动态分配的长度可以是变量，也可以是输入的数值。 不同于Java，C++的数组可以分配在栈上（静态分配（int a[5]）。 Java除了
动态二维数组类（C++ Vector)
weixin_54186646的博客
03-12 9832
C++、vector、类实现二维动态数组，运算符重载，矩阵相加、矩阵相乘
C++如何动态分配二维数组？
最新发布
默示MoS的博客
08-18 944
动态分配二维数组的细节，你想要的这里都有
C++ 动态创建二维数组
菜鸟学编程
11-02 1万+
背景知识： 对二维数组的理解方式至关重要：把二维数组看成是一种特殊的一维数组，它的元素又是一个一维数组。 例如：int a[3][4], 可以理解为定义了3个一维数组，即相当于 a[0], a[1], a[2], 而它们的每个元素又是一个包含4个元素的一维数组，即： a[0]: a[0][0], a[0][1], a[0][2], a[0][3] a[1]: a[1][0], a[1][...
计算机语言中c/c++的基础入门学习代码记录（适应于计算机二级）
01-26
04二维数组；05字符数组和字符串；06字符串比较） 6.函数（01随机数；02函数定义使用；03函数类型；04函数值传递；05函数调用；06嵌套调用；07函数递归传递；08局部变量和全局变量） 7.编译预处理（01无参数；02有...
172集通俗易懂的C语言从入门到项目实战教程
06-16
3) 课程详细内容: 常量-变量、分支语句、循环语句、操作符和表达式、函数(库函数、自定义函数、递归调用 )、数组(一维数 组、二维数组、数组作为函数参数、指针数组)、指针(指针和指针类型、二级指针和多级指针、...
计算机C语言程序设计考试附带答案 本文链接：https://blog.csdn.net/Candy5204/article/de
05-24
现需要设计一个处理二维平面整型数据的程序，平面的行数和列数不可预知（需要在程序运行过程中输入）。要求处理的方式是其奇数行按降序排序，偶数行按升序排序。请编制实现上述功能的程序，使用随机数据检验程序的...
C／C++常用算法手册.秦姣华(有详细书签).rar
04-17
6.2.2 二维多项式求值 158 6.2.3 多项式乘法 160 6.2.4 多项式除法 161 6.3 随机数生成算法 164 6.4 复数运算 171 6.4.1 简单的复数运算 172 6.4.2 复数的幂运算 174 6.4.3 复指数运算 176 6.4.4 复对数...
二级c未来教育题库破解及资源
09-25
２.一维、二维数组和字符串的地址以及指向变量、数组、字符串、函数、结构体的指针变量的 定义。通过指针引用以上各类型数据。 ３.用指针作函数参数。 ４.返回地址值的函数。 ５.指针数组，指向指针的指针。 ...
C++ 动态分配二维数组
lizhentao0707的博客
07-21 4643
C++ 动态分配二维数组 (1) 使用new分配二维数组 #include&lt;iostream&gt; using namespace std; int main() { // new动态分配二维数组 int row_num, col_num; // row_num:行数；col_num：列数 cin &gt;&gt; row_num &gt;&gt; col_num; ...
C++中动态分配二维数组的方法
河岸之城 的专栏
11-08 328
#define N 4 typedef int p[N];//方法一用到 using namespace std; int main() {     int n = 0;     //方法一：使用typedef定义一个具有N个元素的数组类型     p *ptr1;      //定义二维数组??用法与二维数组相同     ptr1 = new p
如何在C++中动态分配二维数组
weixin_34032621的博客
06-01 56
一般是三种方法：(1)用vector的vector，(2)先分配一个指针 数组，然后让里面每一个指针再指向一个数组，这个做法的好处是访问数组元素时比较直观，可以用a[x][y]这样的写法，缺点是它相当于C#中的一个锯齿 数组，内存空间不连续。(3)直接分配一个x*y大小的一维数组，这样保证空间是连续的，但访问数组元素不直观。对于我这个“经典”回答，我那时还一直是 挺得意的，至少从蹭分的角度来看，这...
C++二维数组动态内存分配
05-26 792
对于二维数组和二维指针的内存的分配 这里首选说一下一维指针和一维数组的内存分配情况。 一维： 数组：形如int a[5];这里定义了一个一维数组a,并且数组的元素个数是5，这里的a是这五个元素的整体表示，也就是通过a我们能找到这五个元素。注意：a是代表数组第一个元素的首地址。&a是代表数组的地址，虽然它们的值相同。 指针： int *p = NULL；这里p是一个指针，...
c++动态创建二维数组
Will Mu 的专栏
04-24 2768
方法1：用一维数组代替二维数组 int n,m; 　　cin>>n>>m; 　　int* a = new int[n*m]; 　　for(int i = 0 ; i<n ; ++i) 　　{ 　　cout<<endl; 　　for(int j = 0 ; j<m ; ++j) 　　{ 　　a[i*m+j] = i+j; 　　cout<<a[i*m+j]<<" "<<&a
面试题16 部分排序
WormholeStack
06-15 751
###题目描述 给定一个整数数组，编写一个函数，找出索引m和n，只要将索引区间[m,n]的元素排好序，整个数组就是有序的。注意：n-m尽量最小，也就是说，找出符合条件的最短序列。函数返回值为[m,n]，若不存在这样的m和n（例如整个数组是有序的），请返回[-1,-1]。 示例： 输入： [1,2,4,7,10,11,7,12,6,7,16,18,19] 输出： [3,9] 提示： 0 <= len(array) <= 1000000 解题思路 首先理解题意 [1,2,4,7,10,11,7
C/C++动态内存及二维数组的动态分配
JuniorChestnut的博客
05-13 1346
1.malloc （1）malloc分配函数：需要给出申请空间大小（以字节为单位） （2）返回值是一个首地址，用指针接收 （3）使用sizeof计算元素大小 （4）使用malloc函数申请内存空间，用完后需要释放，否则会造成内存泄露 （5）释放函数free需要指向分配内存的指针 （6）基本形式：void malloc(unsigned int size); （7）分配指定大小的内存空间，但是不会把分配的空间清0 （8）free(指针);//释放堆空间，标记删除，不清楚内容 （9）示例： ①malloc与一维
【学习C++】创建动态二维数组
热门推荐
开源节流
01-19 5万+
1   int **a=new int*[l];a[i]=new int[l]; #include using namespace std; //int l=2; int main() { int l,i,j; cout<<"l"<<endl; cin>>l; int **a=new int*[l]; for(i=0;i<l;i++) a[i]=new int[l]; fo
C#Array.sort()二维数组
04-06
C是一种计算机编程语言，由Dennis Ritchie在20世纪70年代初开发。C语言被广泛用于系统编程、嵌入式系统、操作系统、网络编程以及游戏开发等领域，是一种高效、灵活、可移植的语言。C语言的语法简洁、结构清晰，易于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值