精华内容
下载资源
问答
  • 动态分配二维数组

    2017-04-06 08:28:16
    动态分配二维数组的两种方式

    //方式一:
    #include <iostream>
    using namespace std;
    void main()
    {
    int **arr;
    int row,column;
    cin>>row>>column;
    arr=new int*[column];
    for(int i=0;i<row;i++)
    {arr[i]= new int[column];}
    for(int i=0;i<row;i++)
    {
    for(int j=0;j<column;j++)
    {
    arr[i][j]=3;cout<<arr[i][j]<<" ";
    }
    cout<<endl;
    }
    }
    //方式二:
    #include <stdio.h>
    #include <malloc.h>
    void main()
    {
    int row,column;
    scanf("%d%d",&row,&column);
    int **arr;
    arr=(int **)malloc(row*sizeof(int *));
    for(int i=0;i<row;i++)
    arr[i]=(int*)malloc(column*sizeof(int));
    for(int i=0;i<row;i++)
    {
    for(int j=0;j<column;j++)
    {
    arr[i][j]=3;
    printf("%d ",arr[i][j]);
    }
    printf("\n");
    }
    printf("\n");
    }

    展开全文
  • C语言中动态分配二维数组 在C中动态分配内存的对于单个变量字符串一维数组等都是很容易的C中动态分配二维数组的方法很少有C语言书中描述我查找了有的C语言书中提到了一个方法 假定二维数组的维数为[M][N] 分配是...
  • C语言中动态分配二维数组 在C中动态分配内存的对于单个变量字符串一维数组等都是很容易的C中动态分配二维数组的方法很少有C语言书中描述我查找了有的C语言书中提到了一个方法 假定二维数组的维数为[M][N] 分配是可以...
  • C语言动态分配二维数组 二维数组可以看成是指向数组的指针构成的数组,即指针数组,用来存放数组指针。 1、使用malloc分配二维数组时,可以先分配包含有n个指针元素的一维数组: 例如:分配具有m行n列个元素的二维...

    C/C++动态分配多维数组


    二维数组可以看成是指向数组的指针构成的数组,即指针数组,用来存放数组指针。
    1、使用malloc分配二维数组时,可以先分配包含有n个指针元素的一维数组,例如:

    //1.分配具有m行n列个元素的二维数组
    int **p = (int **)malloc(sizeof(int *)*n);
    //2.然后为每个指针元素分配数组
    for(int i = 0;i < n;i++)
    {
    	*(p+i) = (int *)malloc(sizeof(int)*m);
    }
    //3、int a[m][n];我的理解为,列的个数为数组的个数,行的个数为数组的元素个数,int a[m],[n]理解为n个数组,每个数组含有m个元素。
    //4、使用\*(p+i)指向具体的行,是一个指针,指向数组的首地址,用\*(\*(p+i)+j) 可以访问到具体行的具体元素。
    //5、释放
    for(int i = 0;i < n;i++)
    {
    	free(*(p + i));
    }
    free( p );
    

    c++二维数组动态分配:

    //假定数组第一维长度为 m, 第二维长度为 n
    //分配
    int **p = NULL;
    p = new int *[m];
    for(int i = 0;i < m;i++)
    {
    	p[i] = new int[n];
    }
    //释放
    for(int i = 0;i < m;i++)
    {
    	delete [] p[i];
    }
    delete [] p;
    

    C++动态分配三维数组

    //假定三维数组第一维为 m, 第二维为 n, 第三维为h
    // 动态分配空间
    int ***parr = NULL;
    parr = new int**[m];
    for(int i = 0;i < m;i++)
    {
    	parr[i] = new int*[n];
    	for(int j = 0;j < n;j++)
    	{
    		parr[i][j] = new int[h];
    	}
    }
    //释放
    for(int i = 0;i < m;i++)
    {
    	for(int j = 0;j < n;j++)
    	{
    		delete [] parr[i][j];
    	}
    	delete [] parr[i];
    }
    delete [] parr;
    

    6、顺便记录一下数组指针和指针数组的定义方式
    int *parr[10];//指针数组
    int (*parr)[10];//数组指针

    展开全文
  • int *a[col] = (int *) malloc(col * sizeof(int)); 这一句话为什么错了,为什么不能用指针数组动态分配二维数组? 是不是只能用int **a才能动态分配二维数组
  • C++ 动态分配二维数组

    千次阅读 2018-07-21 10:56:13
    C++ 动态分配二维数组 (1) 使用new分配二维数组 #include&lt;iostream&gt; using namespace std; int main() { // new动态分配二维数组 int row_num, col_num; // row_num:行数;col_num:列数 cin ...

    C++ 动态分配二维数组

    (1) 使用new分配二维数组

    #include<iostream>
    
    using namespace std;
    
    int main()
    {
    	//  new动态分配二维数组
    	int row_num, col_num;  //  row_num:行数;col_num:列数
    	cin >> row_num >> col_num;
    	int **arr = new int *[row_num];
    	for (int i = 0; i < row_num; i++)
    	{
    		arr[i] = new int[col_num];
    	}
        //  输入
    	for (int i = 0; i < row_num; i++)
    	{
    		for (int j = 0; j < col_num; j++)
    		{
    			cin >> arr[i][j];
    		}
    	}
    
    	//  delete释放二维数组
    	for (int i = 0; i < row_num; i++)
    		delete[]arr[i];
    	delete[]arr;
    	return 0;
    }

    (2 使用vector直接初始化二维数组

    	vector<vector<int>> ivec(row_num, vector<int>(col_num, 0));
    

     

    展开全文
  • 如何在C/C++中动态分配二维数组

    万次阅读 多人点赞 2012-06-18 10:34:26
    如何在C/C++中动态分配二维数组在C/C++中动态分配二维数组可以先申请一维的指针数组,然后该数组中的每个指针再申请数组,这样就相当于二维数组了,但是这种方法会导致每行可能不相邻,从而访问效率比较低。...

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

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

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

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

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

     

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

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

    //列大小固定的二维数组可以申请一维数据并将指针强转成二维数组
    #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*4int类型数组,我们先申请大小为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)这个位置的指针。下面用图展示指向的示意:

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

    //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里面运用还是比较多的,有兴趣的童鞋应该掌握下。

    //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

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



     

    展开全文
  • 下面小编就为大家带来一篇C与C++动态分配二维数组的实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 动态分配二维数组内存需要使用指针的指针。多维数组的内存布局是不连续的,所以应首先为数组的第一个下标分配一个连续的数组。该数组的每个元素是指向另一个数组的指针,另一个数组保存的是第二个下标维度的元素。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,513
精华内容 605
关键字:

动态分配二维数组