精华内容
下载资源
问答
  • 定义动态数组

    2017-03-04 21:59:38
    利用new 函数定义动态数组new和delete运算符用于动态分配和撤销内存的运算符开辟一维数组

    利用new 函数定义动态数组

    new和delete运算符用于动态分配和撤销内存的运算符

    开辟一维数组
    m=8;
    int *t=new int [m];//开辟一维动态数组,相当于t[m]
    int *t=new int[8];//开辟一个空间为8的整型数组空间
    int *t=new int(8);//开辟了一个整型且赋值为8的空间
    int *t=new int;//开辟单变量地址空间,即将int类型的空间地址赋给指针t;
    销毁一维动态数组
    int t=new int[8]
    delete [] t//释放int数组空间
    int t=new int
    delete a//释放单个int的空间

    开辟二维动态数组

    int (*a)[10];
    a=new a[10][10];
    
    
    m=8;n=9;
    int **t=new int*[n];
     for(int i=0;i<n;i++)
        t[i]= new int[m];
    
    
    int **t;
    *t =new int [m];或者t =new int *[m]
    for(i=0;i<m;i++)
        t [i]=new int [n];

    销毁二维动态数组

    for(int i=0;i<m;i++)
            delete[] FileFeature [i];
        delete[] FileFeature ;

    备注:动态数组开辟后,用完一定要销毁,不然可能出现内存不足的提示。

    怎样让函数返回数组

    http://www.cnblogs.com/yangxi/archive/2011/09/18/2180759.html

    参考链接

    http://blog.csdn.net/hondely/article/details/6779887
    http://www.cnblogs.com/cj695/archive/2011/10/28/2227530.html
    http://jingyan.baidu.com/article/5552ef473f91f7518ffbc9aa.html

    展开全文
  • C++中如何定义动态数组

    万次阅读 多人点赞 2017-04-22 22:15:59
    C++中如何定义动态数组 http://blog.csdn.net/bzhxuexi/article/details/17230073 标签: C++动态数组 2013-12-09 21:27 3145人阅读 评论(0) 收藏 举报  分类: C/C++(105)  首先:为什么需要...

    C++中如何定义动态数组

    http://blog.csdn.net/bzhxuexi/article/details/17230073

    标签: C++动态数组
     3145人阅读 评论(0) 收藏 举报
     分类:

    首先:为什么需要动态定义数组呢?
      这是因为,很多情况下,在预编译过程阶段,数组的长度是不能预先知道的,必须在程序运行时动态的给出
      但是问题是,c++要求定义数组时,必须明确给定数组的大小,要不然编译通不过 
     
      如: int Array[5];正确

           int i=5;
           int Array[i]; 错误 因为在编译阶段,编译器并不知道 i 的值是多少

       那么,我们该如何解决定义长度未知的数组呢?
       答案是:new 动态定义数组 

       因为new 就是用来动态开辟空间的,所以当然可以用来开辟一个数组空间
       
       这样,下面的语句:
        int size=50;
        int *p=new int[size]; 是正确的
     
       但是二维动态数组能不能也这样定义呢
       
      int size=50,Column=50;
      int (*p)[Column]=new int [size][Column]

      这样的语句,编译器通不过,为什么呢?
      首先 new int[size][Column] 就是动态生成时确定的,所以它没有错
      那么就是 int(*p)[Column],这句有问题了,这句为什么不对呢, 那是因为,这是一个定义语句,而定义语句先经过编译器进行编译,当编译器运行到此处时,发现Column 不是常数,因此不能通过编译。 而之所以编译器认为Column 不是常数,是因为编译阶段,编译器起的作用是查语法错误,和预分配空间,它并不执行程序,因此,没有执行那个赋值语句(只是对这个语句检查错误,和分配空间),因此编译阶段,它将认为column 是个变量。所以上面的二维数组定义是错误的, 它不能通过编译。

      改成这样:
      int size=50
      int (*p)[50]=new int [size][50]
      便正确了。

       由此可见,这种动态分配数组,仅对一维数组空间是真正动态分配的。
       但是如何真正的动态分配二维数组呢,即如果Column 也不能预先知道的话,该如何处理呢?
       
       上面的动态分配已经不能满足我们的要求,因为上面动态分配只对一维数组是真正动态的,对二维数组的话,必须编译之前预先知道二维数组每一列的长度,而这个长度在很多情况下是不能预先知道的,所以我们得结合其他方法来解决这个问题。
       
       既然一维是真正的动态分配的话,那我们利用这一特性定义一个指针数组。
       
       int **p= new int*[size];//定义指针数组 
       int *p[5];//  假若知道二维数组的行数为5

       然后对指针数组中的每一个指针分配一个一维数组空间,这样便动态定义了二维数组
      
       事实上,我认为指针数组的主要用途,就在于动态定义多维数组
        
        for(int i=0;i<size;i++)
       {
         p[i]=new int[Column];
       }
       
       运行完毕后,一个二维数组便被动态的成功建立

    -----------------------------------

     

    例子:

     

       size =6;

     

       column =5

     

       int **p=new int*[size];

     

        for(int i=0;i<size;i++)
       {
         p[i]=new int[Column];
       }

     

     

     

    所生成的动态数组如下图所示:

     

     

     
       

      最后 ,因为调用了new, 千万千万别忘记在用完之后,将其所占资源 delete 掉

     

      下面是delete方法:

        for(int i=0;i<size;i++)
       {

               delete []  p[i];   // 要在指针前加[] , 否则的话 只释放p[i]所指的第一个单元所占的空间
       }

     

       delete [] p;     //最后不要忘掉 释放掉开辟的指针数组  :》


    // ArrayTest.cpp : 定义控制台应用程序的入口点。
    //
    
    
    #include "stdafx.h"
    #include "ArrayTest.h"
    #include <afxstr.h>
    
    
    #ifdef _DEBUG
    #define new DEBUG_NEW
    #endif
    
    
    // 唯一的应用程序对象
    
    
    CWinApp theApp;
    
    
    using namespace std;
    
    
    // ArrayTest.cpp : 定义控制台应用程序的入口点。
    //
    
    
    CString** CreateCStringArray(UINT colcount, UINT rowcount){
    	CString** strMsg = new CString*[colcount];
    	for (UINT i = 0; i < colcount; i++)
    	{
    		strMsg[i] = new CString[rowcount];
    	}
    	return strMsg;
    }
    POINT** CreatePOINTArray(UINT colcount, UINT rowcount)
    {
    	POINT** Point = new POINT*[colcount];
    	for (UINT i = 0; i < colcount; i++)
    	{
    		Point[i] = new POINT[rowcount];
    	}
    	return Point;
    }
    
    
    void DeleteCStringArray(UINT size, CString** pstr)
    {
    	for (unsigned int i = 0; i < size; i++)
    	{
    		delete[]  pstr[i];   // 要在指针前加[] , 否则的话 只释放p[i]所指的第一个单元所占的空间
    	}
    }
    
    
    void DeletePOintArray(UINT size, POINT** pPoint)
    {
    	for (UINT i = 0; i < size; i++)
    	{
    		delete[]  pPoint[i];   // 要在指针前加[] , 否则的话 只释放p[i]所指的第一个单元所占的空间
    	}
    }
    
    
    int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
    {
    	int nRetCode = 0;
    
    
    	HMODULE hModule = ::GetModuleHandle(NULL);
    
    	if (hModule != NULL)
    	{
    		// 初始化 MFC 并在失败时显示错误
    		if (!AfxWinInit(hModule, NULL, ::GetCommandLine(), 0))
    		{
    			// TODO:  更改错误代码以符合您的需要
    			_tprintf(_T("错误:  MFC 初始化失败\n"));
    			nRetCode = 1;
    		}
    		else
    		{
    			// TODO:  在此处为应用程序的行为编写代码。
    
    
    			// 定义字符串数组--动态数组
    			CString** strMsg = CreateCStringArray(8, 16);
    			strMsg[0][0] = L"AddressWidth";
    			strMsg[0][1] = L"Architecture";
    			strMsg[0][2] = L"Availability";
    			strMsg[0][3] = L"Caption";
    			strMsg[0][4] = L"ConfigManagerErrorCode";
    			strMsg[0][5] = L"ConfigManagerUserConfig";
    			strMsg[0][6] = L"CpuStatus";
    			strMsg[0][7] = L"CreationClassName";
    			strMsg[0][8] = L"CurrentClockSpeed";
    
    
    			strMsg[2][0] = L"InstallDate";
    			strMsg[2][1] = L"L2CacheSize";
    			strMsg[2][2] = L"L2CacheSpeed";
    			strMsg[2][3] = L"L3CacheSize";
    			strMsg[2][4] = L"L3CacheSpeed";
    			strMsg[2][5] = L"LastErrorCod";
    			strMsg[2][6] = L"Level";
    			strMsg[2][7] = L"LoadPercentage";
    			strMsg[2][8] = L"Manufacturer";
    			strMsg[2][9] = L"MaxClockSpeed";
    			strMsg[2][10] = L"Name";
    			strMsg[2][11] = L"NumberOfCores";
    			strMsg[2][12] = L"NumberOfLogicalProcessors";
    			strMsg[2][13] = L"OtherFamilyDescription";
    			strMsg[2][14] = L"PNPDeviceID";
    			strMsg[2][15] = L"PowerManagementCapabilities";
    
    
    			strMsg[4][0] = L"ProcessorId";
    			strMsg[4][1] = L"ProcessorType";
    			strMsg[4][2] = L"Revision";
    			strMsg[4][3] = L"Role";
    			strMsg[4][4] = L"SocketDesignation";
    			strMsg[4][5] = L"Status";
    			strMsg[4][6] = L"StatusInfo";
    			strMsg[4][7] = L"Stepping";
    			strMsg[4][8] = L"SystemCreationClassName";
    			strMsg[4][9] = L"SystemName";
    			strMsg[4][10] = L"UniqueId";
    			strMsg[4][11] = L"UpgradeMethod";
    			strMsg[4][12] = L"VoltageCaps";
    			
    			strMsg[4][13] = L"ErrorCleared";
    			strMsg[4][14] = L"ErrorDescription";
    			strMsg[4][15] = L"ExtClock";
    
    
    			strMsg[6][0] = L"InstallDate";
    			strMsg[6][1] = L"L2CacheSize";
    			strMsg[6][2] = L"L2CacheSpeed";
    			strMsg[6][3] = L"L3CacheSize";
    			strMsg[6][4] = L"L3CacheSpeed";
    			strMsg[6][5] = L"LastErrorCod";
    			strMsg[6][6] = L"Level";
    			strMsg[6][7] = L"LoadPercentage";
    			strMsg[6][8] = L"Manufacturer";
    			strMsg[6][9] = L"MaxClockSpeed";
    			strMsg[6][10] = L"Name";
    			strMsg[6][11] = L"NumberOfCores";
    			strMsg[6][12] = L"NumberOfLogicalProcessors";
    			strMsg[6][13] = L"OtherFamilyDescription";
    			strMsg[6][14] = L"PNPDeviceID";
    			strMsg[6][15] = L"PowerManagementCapabilities";
    
    
    			for (UINT i = 0; i < 8; i++)
    			{
    				for (UINT j = 0; j < 16; j++)
    				{
    					printf("%ls\n", strMsg[i][j]);
    				}
    				printf("--------------i = %d\n", i);
    			}
    
    
    			DeleteCStringArray(8, strMsg);
    			 定义坐标数组
    			POINT** Point = CreatePOINTArray(8, 16);
    			POINT p1;
    			p1.x = 1.0;
    			p1.y = 2.0;
    
    
    			Point[0][0] = p1;
    			Point[0][1] = p1;
    			Point[0][2] = p1;
    			Point[0][3] = p1;
    			Point[0][4] = p1;
    			Point[0][5] = p1;
    			Point[0][6] = p1;
    			Point[0][7] = p1;
    			Point[0][8] = p1;
    
    
    			Point[1][0] = p1;
    			Point[1][1] = p1;
    			Point[1][2] = p1;
    			Point[1][3] = p1;
    			Point[1][4] = p1;
    			Point[1][5] = p1;
    			Point[1][6] = p1;
    			Point[1][7] = p1;
    			Point[1][8] = p1;
    
    
    			for (UINT i = 0; i < 8; i++)
    			{
    				for (UINT j = 0; j < 16; j++)
    				{
    					printf("%d\n", Point[i][j]);
    				}
    				printf("--------------i = %d\n", i);
    			}
    			DeletePOintArray(8, Point);
    		}
    	}
    	else
    	{
    		// TODO:  更改错误代码以符合您的需要
    		_tprintf(_T("错误:  GetModuleHandle 失败\n"));
    		nRetCode = 1;
    	}
    	return nRetCode;
    }
    
    
    


    展开全文
  • C语言定义动态数组

    千次阅读 2019-03-31 15:23:45
    今天在unbutu写一道简单的约瑟夫环的问题:有n个人,循环报数,报到3的人淘汰,求最后剩下的人,我就想定义一个动态数组来记录他们是否被淘汰`,如果淘汰了就把他对应数组中的...我们定义动态数组的时候,如果我们像...

    今天在unbutu写一道简单的约瑟夫环的问题:有n个人,循环报数,报到3的人淘汰,求最后剩下的人,我就想定义一个动态数组来记录他们是否被淘汰`,如果淘汰了就把他对应数组中的值改为0,淘汰n-1个人之后,数组中值为1的人就是最后剩下的人。

    int n;
    printf("请输入总人数:\n");
    scanf("%d",&n);
    int a[n] = {1};

    我们定义动态数组的时候,如果我们像上面这样写编译的时候就会报错,我在网上看到分配动态数组都是像下面这样写的

    int n;
    printf("请输入总人数:\n");
    scanf("%d",&n);
    int *a;
    a = (int *)malloc(sizeof(int)*n);

    这里定义了一个指针a,然后用malloc分配了内存,a指向了分配的内存空间的首地址,我们想要给它赋值的时候可以用*(a+i)进行赋值,这样编译的时候是可以的。但是我们像下面这样写也是可以的。

    int i;
    int n;
    printf("请输入总人数:\n");
    scanf("%d",&n);
    int a[n];
    for(i = 0;i = n;i++)
    {
        a[i] = 1;
    }

    在我的印象中c语言应该是没办法分配动态数组的,在定义数组的时候必须确定数组的大小,但是上面这个代码编译时可以的,只要int a[n]在执行时n已经有确定的值的时候是可以通过的,但是我们不可以在定义动态数组的同时进行初始化,像第一个代码就会报错。

    展开全文
  • 问题在写程序时有时候需要定义一个长度为n的数组,但n是一个变量 在C语言中一定不可以这样写: #include C语言中无法动态定义一个数组长度[^1]解决思路可以向计算机申请一个长度为n的内存代码如下 一维动态数组的...

    问题

    在写程序时有时候需要定义一个长度为n的数组,但n是一个变量

    在C语言中一定不可以这样写:

    #include 

    C语言中无法动态定义一个数组长度[^1]


    解决思路

    • 可以向计算机申请一个长度为n的内存代码如下
    • 一维动态数组的创建:

    1. 使用malloc

    #include 

    2. 使用calloc

    #include 

    运行结果截图:

    ce1e872875a06e55732e28a29a35f133.png

    二维动态数组的创建:

    因为二维数组的本质是数组的数组所以由上可以类推下去给外层中的每一个内层数组动态申请内存即可[^2]

    C语言代码如下:

    #include 

    运行结果截图:

    409eb52578c607bdb1996c670cb8085f.png

    多维动态数组的创建:

    对于多维数组的创建,其实也是一个道理,在每个维度创建即可。


    大家可以关注下我的b站,之后我会在上面直播相关教学,大家可以来点波关注一起学习,共同进步。

    展开全文
  • c语言定义动态数组

    千次阅读 2018-12-01 20:58:19
    我们可以通过一段简单的代码示例来体会一下c语言定义动态数组 使用malloc.h头文件 #include &amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;malloc.h&amp;amp;...
  • C++BUILDER 编译器可以定义动态数组。VS如何定义一个动态数组呢?就是数组长度可以改变的那种。不是使用malloc函数哦。如果有,那么相关的函数包含在哪个头文件里?
  • 如何使用C语言动态定义动态数组长度 问题 在写程序时有时候需要定义一个长度为n的数组,但n是一个变量 在C语言中一定不可以这样写: #include <stdio.h> int main () { int n; scanf("%d",&n); int num...
  • C++定义动态数组

    2014-09-23 10:52:06
    C++定义动态数组 首先:为什么需要动态定义数组呢?  这是因为,很多情况下,在预编译过程阶段,数组的长度是不能预先知道的,必须在程序运行时动态的给出  但是问题是,c++要求定义数组时,必须明确给...
  • C#定义动态数组(泛型)

    千次阅读 热门讨论 2015-01-09 21:58:33
    C#定义动态数组
  • 数组基础回顾1、数组是一种常见的数据结构,用来存储同一类型值的集合2、数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致3、数组是一种顺序存储的线性表,所有元素的内存地址是连续的4、例如:new 一...
  • 今天就为大家介绍一下java如何手写动态数组,并用实际代码展示。一起来看看吧。首先说一下注意事项。1.在定义增量时,不要定义成一个固定的值,每次扩充一定比例。2.比例不是越大越好,也要考虑到内存问题,所以取个...
  • c# 定义动态数组方法

    千次阅读 2013-11-12 14:17:56
    c# 定义动态数组方法:  private Vector3 []a ; //保存点的位置 private float []v ;//保存从数据库中读取的float数值 在初始化函数start中定义如下:  num=20; a = new Vector3 [num]; v = new float...
  • C++中定义动态数组

    千次阅读 2017-05-25 18:23:57
    C/C++ 规定,数组一旦定义后,它的长度就不能改变...静态数组有时候会给编码代码不便,我们可以通过自定义的 Array 类来实现动态数组(Dynamic array)。所谓动态数组,是指数组容量能够在使用的过程中随时增大或减小。
  • 问题在写程序时有时候需要定义一个长度为n的数组,但n是一个变量 在C语言中一定不可以...}C语言中无法动态定义一个数组长度[^1]解决思路可以向计算机申请一个长度为n的内存代码如下 一维动态数组的创建:1. 使用m...
  • c++ 定义动态数组

    2016-04-11 18:25:22
    今天神奇的发现c++可以在函数内这样定义数组。 int t = 10; int A[t]; 并没有出错,不过在全局变量这样定义就会出错。
  • 一维数组: #include <...//一定要注意先输入c再定义数组 for(i=0;i<c;i++) { cin>>p[i]; } for(i=0;i<c;i++) { if(i!=c-1) { cout<<p[i]<<' '; } else
  • 今天在给学生培训的时候,讲到C语言中定义数组的时候,数组的长度只能是常量和常量表达式,而不能是变量(不能动态定义数组)。通过一段代码进行演示。 #include<stdio.h> int main() { int len; scanf("%...

空空如也

空空如也

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

定义动态数组