精华内容
下载资源
问答
  • new创建多维数组时,最后需要用delete,但是我在delete时遇到了麻烦,实在不能再浪费时间了,先mark一下,至少创建多维数组这段是对的 以int型数组为例,我们知道 ...三维数组 int c[2][3][4] = {

    用new创建多维数组时,最后需要用delete,但是我在delete时遇到了麻烦,实在不能再浪费时间了,先mark一下,至少创建多维数组这段是对的

    以int型数组为例,我们知道

    一维数组  int a[4] ={1,2,3,4};

    二维数组  int b[3][4] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4}

    三维数组  int c[2][3][4] = {1,2};


    那么用new方式如何创建呢

    一维数组有

    int *p1 = new int[4];

    二维数组有

    int (*p2)[4] = new int[3][4];


    三维数组

    int (*p3)[3][4] = new int[2][3][4];//两维三行四列


    同样的四位数组

    int (*p4)[2][3][4] = new int[1][2][3][4];//不知道怎么叫了


    忘了从哪里看到的说: 从二维数组开始,定义并不是写成  int *p2[4]、int * p3[3][4]、...这是因为int * p2[4]表示定义一个数组p2,该数组是int *型,数组内的每个元素都是指向int型的指针。

    	//step 1定义多维数组
    
    	//int *q1 = new int[4];  //创建一维数组,暂时不用
    	//int (*q2)[4] = new int[0][4];//创建二位数组,暂时不用
    	int (*p)[3][4] =  new int[2][3][4];//创建三维数组,本文研究的重点,我为了少打字,这个变量我定义成了p,并不是p3
    	//int (*p4)[3][4][5] = new int [0][3][4][5];//创建四维数组
    
    	//留个标记,用于
    	//存放这些数组的指针,用于验证是否delete时会用到
    	int *backup[24];
    	int imark = 0;
    
    	//循环将三维数组每个元素均赋值为1
    	printf("------初始化得到的二维数组----\n");
    	for(int i = 0;i< 2;i++)
    	{
    
    		for(int j = 0;j<3;j++)
    		{
    			for(int k = 0;k<4;k++)
    			{
    				printf("%d --->",(*(*(p+i)+j)+k));//初始化之前均为0
    				printf("%d ",*(*(*(p+i)+j)+k));//这里打印了new出来的三维数组,本层循环最后将每个值赋值成了1
    
    
    				backup[imark++] = (*(*(p+i)+j)+k);
    				*(*(*(p+i)+j)+k) = 1;//这里将每个元素赋值成了1,为的是方便后面delete时对比查看
    
    			}
    			printf("\n");
    		}
    
    	}
    
    	printf("---------------------\n");//
    
    	//step 2 准备检验
    
    	//前辈说书中讲的,数组的大小在之前的四个字节内存储着,究竟是啥呢,在这里可以打印查看printf("front 4 byte is %d, -->%d\n",&p[0][0][0]-1,(int)*(&p[0][0][0]-1));printf("p[0][0][0] address is %d\n",&p[0][0][0]);printf("p[1][2][3] address is %d\n",&p[1][2][3]);printf("\n");//这里尝试了好多种delete的方式都没有成功???╮(╯▽╰)╭
    	//第一种尝试,直接删除p数组,这个似乎从原理上很容易否定
    	/*
    	delete []p;//这种方式发现只删除了new出来的前两个元素
    
    	*/
    
    	//第二种尝试,借用一下保存的指针,用指针一个一个去free
    	/*
    	for(int i =0;i<24;i++)
    	{
    	delete backup[i];//用backup中记忆的位置一个一个删除,发现行不通,&backup[i]也行不通
    	//delete []backup;//这种也是行不通的,我注解上了,可以试试
    	}
    
    	*/
    
    	//第三种尝试,嵌套进入生成的数组,一层一层的去free,然而依然失败,不知道是重复删除了,还是怎么了,感觉是重复删除了
    	for(int i = 0;i<2;i++)
    	{
    		for(int j = 0;j<3;j++)
    		{
    			delete [] p[i][j];
    		}
    	delete []p[i];
    	}
    
    
    	//第四种尝试,一个一个删,但依然没有成功,我从大到小,先小到大均试了一次,依然失败,下面写的是从大到小
    	/*
    	delete p[1][2][3];//不要搞混乱,2*3*4维数组最大值就是这个
    	delete p[1][2][3];//不列写了,因为占篇幅,可以肯定的是没成功
    	//...
    	delete p[0][0][0];
    	*/
    
    
    	//这里面检查是否已经delete了
    	for (int i = 0; i < 24; i++) {
    		if ((i != 0) && (i % 4 == 0))
    		{
    			printf("\n");
    		}
    		printf("[%d]%d--->%d ", i, backup[i], (int) *backup[i]);
    	}
    	printf("\n");
    	return 0;
    


    我目前gdb方式还不会看,另外delete还学得不够深入,再钻进去周末别的也就看不成了,所以得先记下。


    另外粘一个别人new三维数组的方法

    int*** a= new int**[5];
    for (int i = 0; i < 5; ++i)
    {
         a[i] = new int*[6];
         for (int j = 0; j < 6; ++j)
        {
                a[i][j] = new int[7];
         }
    }
    for (int i = 0; i < 5; ++i)
    {
         for (int j = 0; j < 6; ++j)
         {
               delete[] a[i][j];
         }
         delete[] a[i];
    }
    delete[] a;


    就先到这里吧



    展开全文
  • C++用new创建维数组的方法

    万次阅读 多人点赞 2018-01-18 14:23:43
    问题来源在C++中,数组可以被视为一种类型——但是,不存在‘二维数组’这种类型。二维数组本身会被解释成一个一维数组:这个数组的元素...假设a, b为两个int型变量,如果你希望这样生成一个二维数组new int[a][b]

    问题来源

    在C++中,数组可以被视为一种类型——但是,不存在‘二维数组’这种类型。二维数组本身会被解释成一个一维数组:这个数组的元素类型为另一种一维数组。比如int[2][3]这个二维数组,它会被编译器视作一个元素类型为‘int[3]’的一维数组。并且,‘int[3]’和'int[4]'会被当成不同的数据类型。


    假设a, b为两个int型变量,如果你希望这样生成一个二维数组:new int[a][b],是不会得到编译器允许的——因为你没有指定这个数组的元素类型。由于b的大小未知,编译器无法确定‘int[b]’到底是一个什么类型。所以,要用new创建一个二维数组,这其中有讲究。


    方法一:使用常量

    接上:如果将b指定为一个常量,例如new int[a][5],其实质与new int[a]创建一个动态数组并无多大区别——只是元素类型由int变为了'int[5]'而已。

    示例代码:

    [cpp]  view plain  copy
    1. void TestFunc_(unsigned int n)  
    2. {  
    3.     unsigned int i, j;  
    4.   
    5.     // 元素类型为‘int[5]’的数组,可赋值给‘int[5]’类型的指针.  
    6.     int (* array2D)[5] = new int[n][5];  
    7.     for(i=0; i<n; ++i)  
    8.     {  
    9.         for(j=0; j<5; ++j)  
    10.         {  
    11.             array2D[i][j] = i * 5 + j;  
    12.         }  
    13.     }  
    14.   
    15.     // 回收方法和普通动态数组相同,使用'delete[]'即可  
    16.     delete[] array2D;  
    17. }  
    用这个方法来创建二维数组,比较直观、易用,但它最大的限制在于:你必须在编译时确定b的大小


    方法二:使用指针间接引用

    首先创建若干个大小一致的动态数组,然后将这些数组的首地址(转化为指针)按顺序存储到一个动态数组中,就相当于模拟了一个二维动态数组。

    示例代码:

    [cpp]  view plain  copy
    1. void TestFunc_pointer(unsigned int height, unsigned int width)  
    2. {  
    3.     unsigned int i, j;  
    4.   
    5.     //  数组的元素类型为‘int *’,可赋值给指向‘int *’的指针.  
    6.     int **array2D = new int *[height];  
    7.     for(i=0; i<height; ++i)  
    8.     {  
    9.         array2D[i] = new int[width];  
    10.     }  
    11.   
    12.     // 访问.  
    13.     for(i=0; i<height; ++i)  
    14.     {  
    15.         for(j=0; j<width; ++j)  
    16.         {  
    17.             // 内存非连续,注意防止越界.  
    18.             array2D[i][j] = i * width + j;  
    19.         }  
    20.     }  
    21.   
    22.     // 首先回收低一级的动态数组.  
    23.     for(i=0; i<height; ++i)  
    24.     {  
    25.         delete[] array2D[i];  
    26.     }  
    27.     // 然后回收高一级的动态数组.  
    28.     delete[] array2D;  
    29. }  
    这个方法实现了两个维度的动态创建,访问也比较方便。但是有一个缺点:由于低一级的数组是分开创建的,所以整个二维数组的内存不连续——类似‘array2D[i * width + j]’这样的访问就不要使用了,容易造成访问越界


    方法三:使用vector

    借助STL中的vector,我们可以很直观的创建一个二维数组,而不需要用到基本数组的概念。

    示例代码:

    [cpp]  view plain  copy
    1. void TestFunc_vector(unsigned int height, unsigned int width)  
    2. {  
    3.     typedef std::vector<int>  IntVector;  
    4.     typedef std::vector<IntVector>    IntVector2D;  
    5.     unsigned int i, j;  
    6.   
    7.     IntVector2D *pArray2D = new IntVector2D;  
    8.   
    9.     // 动态设置大小.  
    10.     pArray2D->resize(height);  
    11.     for(i=0; i<height; ++i)  
    12.     {  
    13.         (*pArray2D)[i].resize(width);  
    14.     }  
    15.   
    16.     for(i=0; i<height; ++i)  
    17.     {  
    18.         for(j=0; j<width; ++j)  
    19.         {  
    20.             (*pArray2D)[i][j] = i * width + j;  
    21.         }  
    22.     }  
    23.   
    24.     delete pArray2D;  
    25. }  
    可以看到,在vector这个‘更高级’的数组帮助下,我们能够很轻易的创建二维数组。稍微美中不足的是由于引入了STL,程序会变得更大一些——但基本不影响运行速度。


    ==========================End============================

    展开全文
  • #include <iostream> #define n 10 using namespace std;...//创建三重指针 name = new int** [n];//为第一分配空间 for (int i = 0; i < n; i++) { name[i] = new int* [n];//为第二分配空间 ...
    #include <iostream>
    #define n 10
    using namespace  std;
    int main()
    {
    	int*** name;//创建三重指针
    	name = new int** [n];//为第一维分配空间
    	for (int i = 0; i < n; i++)
    	{
    		name[i] = new int* [n];//为第二维分配空间
    		for (int j = 0; j < n; j++)
    			name[i][j] = new int[n];//为第三维分配空间
    	}
    	for (int i = 0; i < n; i++)
    		for (int j = 0; j < n; j++)
    			for (int z = 0; z < n; z++)
    				* (*(*(name + i) + j) + z) = i;//初始化
    	for (int i = 0; i < n; i++)
    	{
    		for (int j = 0; j < n; j++)
    		{
    			for (int z = 0; z < n; z++)
    			{
    				cout << *(*(*(name + i) + j) + z);//输出检验
    			}
    			cout << endl;
    		}
    		cout << endl<<endl;
    	}
    	for (int i = 0; i < n; i++)//释放内存空间
    		for (int j = 0; j < n; j++)
    			delete[]name[i][j];
    	for (int i = 0; i < n; i++)
    		delete[]name[i];
    	delete[]name;
    	return 0;
    }
    
    展开全文
  • C++ 创建三维数组的几种方法

    万次阅读 2016-08-24 10:48:51
    (1)结构体声明三维数组 #include "stdafx.h" #include <iostream> #include <vector> using namespace std; int NX=2100; int NY=400; int NZ=500; int i,j,k; int _tmain(int argc, _TCHAR* argv[])...

    1 结构体声明三维数组

    #include "stdafx.h"
    #include <iostream>
    #include <vector>
    using namespace std;
    int NX=2100;
    int NY=400;
    int NZ=500;
    int i,j,k; 
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	std::vector<std::vector<std::vector<float> > > grdarray(NZ,vector<vector<float> >(NY,vector<float>(NX,0)));
    	for(int z=0;z<NZ;z++)
    	{
    		for (int y=0;y<NY;y++)
    		{
    			for (int x=0;x<NX;x++)
    			{
    				grdarray[z][y][x]=0.0;
    				cout<<grdarray[z][y][z]<<endl;
    			}
    		}
    	}
    	
    }

    2 new动态声明三维数组

    声明二维或者三维数组

    int i,j,k;
     int nWidth,nHeight,nThird;
    
     cin>>nThird>>nHeight>>nWidth;
    
     //声明动态二维数组
     /*int **grayScale = new int * [nHeight];
     for (i = 0;i < nHeight;i++)
     {
      grayScale[i] = new int[nWidth * 3];
     }*/
     //声明一个三维数组
     int ***grayScale = new int ** [nThird];
     for (i = 0;i < nThird;i++)
     {
      grayScale[i] = new int*[nHeight];
      for (j = 0;j < nHeight;j++)
      {
       grayScale[i][j] = new int [nWidth];
      }
     }
    
     for (k = 0;k < nThird;k++)
     {
      for (j = 0;j < nHeight;j++)
      {
       for (i = 0;i < nWidth;i++)
       {
        grayScale[k][j][i] = 1;
       }
      }
     }
    
     cout<<setw(5);
     for (k = 0;k < nThird;k++)
     {
      for (j = 0;j < nHeight;j++)
      {
       for (i = 0;i < nWidth;i++)
       {
        cout<<grayScale[k][j][i]<<setw(5);
       }
       cout<<endl;
      }
      cout<<endl;
     }
    
     释放二维数组
     //for(i = 0;i < nHeight;i++)
     //{
     // delete []grayScale[i];
     //}
     //delete []grayScale;
    
    	//释放三维数组
    	for (j = 0; j < nThird; j++)
    	{
    		for (i = 0; i < nHeight; i++)
    		{
    			delete[]grayScale[j][i];
    		}
    		delete[]grayScale[j];
    	}
    	delete[]grayScale;

    3 malloc动态分配多维数组

    //一维数组
    #include <stdio.h>
    #include <malloc.h>
    #include <string.h>
     
    void main(void)
    {
           int i ;
           char (*p)[12] ; //[5][12]
           p = malloc(5 * sizeof(char ) * 12);     //申请5行的地址空间
     
           for(i = 0 ; i < 5 ; i++)
           {
                  strcpy(*(p + i), "hello");
           }
     
           for(i = 0 ; i < 5 ;i++)
           {
                  printf("%s\n" , *(p + i));
           }
           free(p);
    }
    //二维数组
    #include <stdio.h>
    #include <malloc.h>
    #include <string.h>
     
    void main(void)
    {
           int i;
           int j ;
           int num = 0 ;
           char **p ;//[5][12]
           p =(char **) malloc( 5 * sizeof(char *) );          
     
           for(i = 0 ; i < 5 ; i++)
           {
                  p[i] = malloc(12 * sizeof(char));
           }
     
           for(j = 0 ; j < 5 ; j++)
           {
                  num = 0 ;
                  for(i = 0 ; i < 12 ; i++)
                  {
                         p[j][i] = 'a' + num;
                         num++ ;
                  }
           }
     
           for(j = 0 ; j < 5 ; j++)
           {
                  for(i = 0 ; i < 12 ; i++)
                  {
                         printf("%c" , p[j][i]);
                  }
                  printf("\n");
           }
     
           for(i = 0 ; i < 5 ; i++)
           {
                  free(p[i]);
           }
           free(p);
    }
    //三维数组
    #include <stdio.h>
    #include <malloc.h>
    #include <string.h>
     
    void main(void)
    {
           char ***pStr;
           int i , j , k ;
           // 自己分配一个三维的[3][4][5]
          
           pStr = (char ***)malloc(3 * sizeof(char **));      //第一维
          
           //分配二维的
           for(i = 0 ; i < 3 ; i++)
           {
                  *(pStr + i) = malloc(4 * sizeof(char *));
           }
     
           //分配三维
           for(i = 0 ; i < 3 ; i++)
           {
                  for(j = 0 ; j < 4 ; j++)
                  {
                         *(*(pStr + i) + j) = malloc(5 * sizeof(char));
                  }
           }
     
           //使用分配的内存
           for(i = 0 ; i < 3 ; i++)
           {
                  for(j = 0 ; j < 4 ; j++)
                  {
                         for(k = 0 ; k < 5 ; k++)
                         {
                                pStr[i][j][k] = 'a' ;
                                printf("%c" , pStr[i][j][k]);
                         }
                         printf("\n");
                  }
           }
          
           //释放第三维的内存
           for(i = 0 ; i < 3 ; i++)
           {
                  for(j = 0 ; j < 4 ;j++)
                  {
                         free((pStr[i][j]));
                  }
           }
     
           //释放第二维的内存
           for(i = 0 ; i < 3 ; i++)
           {
                  free(pStr[i]);
           }
     
           //释放第一维的内存
           free(pStr);
    }

     

    如果您觉得这篇博文有用,请访问我的个人站:http://www.stubbornhuang.com,更多博文干货等着您。

    展开全文
  • char **m_GCode = new char*[100]; char ***G = new char**[100]; .c文件中实现: G::G()//构造函数 { for (int i = 0; i m_GCode[i] = new char[100]; for (int i = 0; i { G[i] = new char*
  • c++动态分配空间创建三维数组

    千次阅读 2018-09-19 20:13:23
    #include&lt;iostream&gt; using namespace std;...//创建一个动态的三维数组 for (int i = 0;i&lt;7;i++)//给数组的每一个元素赋值 for(int j = 0;j&lt;9;j++) for(int k = 0; k&lt...
  • 创建维数组种方式: int[] arr1 = new int[6]; int[] arr2 = {1, 2, 3, 4}; int[] arr3 = new int[]{1, 2, 3, 4, 5}; 创建维数组的两种方式: int[][] array2 = new int[5][3];// int[][] array4 = new...
  • JavaScript创建维数组或多维数组

    千次阅读 2019-03-11 11:32:38
    第一种方法:通过数组表达式来创建维数组 var ArrayObj = [ [ 1,2 ], [ 1,2] ]; 评注:这种方法只适用于已知数值,并且数量极少的情况下使用。 第二种方法:通过构造函数来创建维数组 //第一种方式:传递...
  • JavaScript 提供多个内建对象,比如 String、Date、Array 等等。对象只是带有属性和方法的...定义并输出一个二维数组:var arrs=new Array();var arr1=new Array();arr1.push("a");arr1.push("b");arr1.push("c");ar...
  • 果然很麻烦,人生苦短,还是用python吧。#include #include <string.h>int main(void){ int n,m; while(std::cin >>n >>m) { //动态创建维数组 int **a = new int *[n]; for(int i=0; i;
  • PS: 一维数组是指针,可将二维数组看作是指针的指针:每一行是一个一维数组,而列是指向行的指针。在动态创建时,先分配指向行的指针空间,再循环维每一行申请空间。 二维:    三维
  • JavaScript 创建维数组 js不支持真正的二维数组,所以这样写会报错: var array = new Array[5][5]; js 创建数组一般是这样: var array = [1,2,3,4,5]; 所以可以使用两次[]就可以 比如创建一个2行5列的数组: ...
  • c++创建维数组

    千次阅读 2019-02-24 09:19:27
    c++里不在‘二维数组’这种类型,二维数组会被解释为这个一维数组的元素是类型是另一种一维数组。 方法一:使用常量 如果将b声明为一个常量,如new int[a][5],它的实质和一维动态数组没有太大区别只是数组元素被...
  • java 二维数组,三维数组 ,糊糙数组,多维数组示例代码
  • 1、数组: 相同数据的集合。 1.1、定义数组的方法: 类型[] 变量名 = new 类型[数组元素个...1.2、创建和初始化数组:1.2.1、创建时指定大小: //创建时指定大小 int[] arrays = new int[2]; arrays[0] = 1; arr...
  • c++ 用new申请三维数组

    千次阅读 2008-11-19 19:44:00
    int main(){ int ***array; int i,j; int side=5,height=6,width=7; array=new int**[side];//申请side个面 for(i=0;i { array[i]=new int*[height]; for(j=0;j array[i][j]=new int[width]; } 
  • 如何理解Java中的二维数组?二维数组可以看成是以一维数组为元素的一维数组。通常将最外层的一维数组称为外... String[][] province = new Str怎么理解java的二维数组,public class Main { public static void m...
  • C++动态定义三维数组

    千次阅读 2018-09-29 19:06:13
    C++实验作业:动态创建三维数组,各维长度通过输入给定。 #include &lt;bits/stdc++.h&gt; using namespace std; int main() { int height, row, col; //依次为三维数组的高、行、列 cout &lt;&...
  • 今天我们来看一下如何动态地创建维数组,同时可以灵活的指定要创建的数组类型。这里就需要预定义类型:#difine XX 数组类型。计算机在编译代码的的时候进行预处理就会将XX置换为你所定义的数组类型。下面是我的...
  • C/C++创建维数组/指针数组

    千次阅读 2015-09-10 16:45:15
    2.用一维数组模拟二维,即int * p = new int [x * y];分配一个x * y大的数组,然后要用的时候把二维下标映射到一维中,这样做的最大好处是,分配的数组空间是连续的,像一个真正的二维数组,缺点是用起来...
  • 一、一维数组 两种创建数组的语法: 1、构造函数的形式: new Array()  2、创建字面量的形式: [ ] 那么下面我们来分别举个栗子: 第一种创建数组的方法举例 栗2: 用创建字面量的形式: 补充: 获
  • 创建维数组进行学生姓名、学号、Java基础成绩个信息的存储 学生姓名1、学号1、Java基础成绩1 学生姓名2、学号2、Java基础成绩2 学生姓名3、学号3、Java基础成绩3 使用for循环语句进行二维数组的遍历及打印...
  • C++类中动态创建维数组

    千次阅读 2020-05-02 15:56:03
    动态创建维数组 class TwoArray{ public: TowArray(int newRowsize,int newColumnsize){ rowsize = newRowsize; columnsize = newColumnsize; pArray = new int*[rowsize] for(int i =0; i<row...
  • 怎样创建维数组

    2017-08-19 23:39:53
    怎样创建并初始化二维数组? 第一种: var arr=[[1,2,5,7],[2,4,6,8],[5,7,9,11],[6,12,17,19]]; 怎样输出17? 第二种: var arr = new Array(new Array(1,2),new Array("a","b"));alert(arr[1][0]); 第种:...
  • java输出三维数组

    千次阅读 2017-11-09 23:45:13
    三维数组
  • C++动态创建维数组和二维容器

    千次阅读 2019-01-24 21:37:27
    动态创建维数组:   对于一个二维数组p[m][n],将其看成是有m个元素的数组,每个元素都是一个有n个元素的数组。分层次对其进行内存分配。 int m, n; cout &lt;&lt; "Please input the dimension ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,210
精华内容 25,684
关键字:

new创建三维数组