精华内容
下载资源
问答
  • C++ 动态数组

    2017-09-22 20:27:42
    C++ 动态数组 1,C与C++动态数组创建的区别 #include using namespace std; int main() { int n; cout 输入你想创建的数组个数" ; cin >> n; int *p = (int *)malloc(n * sizeof(int)); if(p != NULL) { ...

    C++ 动态数组

    1,C与C++动态数组创建的区别

    #include<iostream>
    using namespace std;
    int main()
    {
    	int n;
    	cout <<"输入你想创建的数组个数" << endl;
    	cin >> n;
    	int *p = (int *)malloc(n * sizeof(int));
    	if(p != NULL)
    	{
    		cout << "创建成功" << endl; 
    	}
    	int *b = new int[n];
    	if(b != NULL)
    	{
    		cout << "创建成功" << endl; 
    	} 
    	return 0;
    }

    从上面代码可以看出C语言在创建动态数组的时候比较麻烦。

    2,动态数组初始化

    #include<iostream>
    #include<string>
    using namespace std;
    int main()
    {
    	int *p = new int[10];//没有初始化
    	string *b = new string[10];//默认的构造函数初始化 
    	int *q = new int[10]();//初始化都为0
    	*q = 1;
    	*(q + 1) =2;
        cout << *(q + 6)<< endl; 
        for(int *a = q;a != q + 10;a ++)
        {
        	cout << *a << endl;
        }
        delete[] p;
        delete[] b;
        delete[] q;
        return 0;
    }



    展开全文
  • c++动态数组

    万次阅读 多人点赞 2018-10-18 13:51:30
    注意:静态数组是在堆栈上(不需要自行释放空间)创建,动态数组是在堆上创建(需要自行释放空间) 涉及内容: 堆(heap)-自由存储区(free store) C语言:malloc和free c++语言:new和delete 1.动态数组定义...

    注意:静态数组是在堆栈上(不需要自行释放空间)创建,动态数组是在堆上创建(需要自行释放空间)

    涉及内容:

    堆(heap)-自由存储区(free store)

    C语言:malloc和free

    c++语言:new和delete

    1.动态数组定义(见后面)

    2.初始化动态数组分配

    string *p_string = new string[10]; //默认的构造函数初始化

    Dog *p_dog = new Dog[10];//调用默认构造函数的初始化

    //动态创建的内置类型数组初始化就要加上一个小括号

    int *pp2 = new int[10]();//使用内置类型的默认值进行初始化

    3.const对象的动态数组

    const指针,这个指针创建了后就不得修改,所以必须首先对其进行初始化操作

    const int *p_const = new const int[100]();

    4.允许动态分配空数组

    5.动态空间的释放

    动态空间的new和delete是成对出现,因此,有了new后就必须进行释放。

    6.动态数组的使用

    动态数组定义:

    为什么需要动态定义数组?

    很多情况下,在预编译过程阶段,数组的长度是不能预先知道的,必须在程序运行时动态的给出,但是问题是,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]

      便正确了。

    new关键字的过程:

    它实际上做了三件事:

    1、获得一块内存空间

    2、调用构造函数

    3、返回正确的指针。

    string *p_string = new string[10]; //默认的构造函数初始化

    Dog *p_dog = new Dog[10];//调用默认构造函数的初始化

    //动态创建的内置类型数组初始化就要加上一个小括号

    int *pp2 = new int[10]();//使用内置类型的默认值进行初始化

    实例:

    #include<iostream>

    using namespace std;

    int main()

    {

    int a[10];//静态数组,在堆栈上创建

    int n;

     

    cout << "你想要多大的数组:" << endl;

    cin >> n;

    //C语言的malloc函数进行书写

    int *p = (int *)malloc(n * sizeof(int));

    if(p != NULL)

    {

    cout << "c语言 malloc创建动态数组成功!" << endl;

     

    }

    //c++创建动态数组

    int *pp = new int[n];//创建新的数组

    if(pp != NULL)

    {

    cout << "c++创建动态数组成功" << endl;

    }

     

    free(p);//c语言创建的数组释放

    delete[] pp;//c++创建的数组进行释放

     

    cout << "hdd";

    }

     

     

    #include<iostream>

    #include<string>

    using namespace std;

    class Dog

    {

     

    };

    int main()

    {

    int a[10];//静态数组,在堆栈上创建

    int n;

    int *pp_int = new int[10];//创建新的数组,没有初始化,一般内置的类型比如int,double都不会初始化

    string *p_string = new string[10]; //默认的构造函数初始化

    Dog *p_dog = new Dog[10];//调用默认构造函数的初始化

    //动态创建的内置类型数组初始化就要加上一个小括号

    int *pp2 = new int[10]();//使用内置类型的默认值进行初始化

    cout << *(pp2+2) << endl;

     

    //参数赋值

    *pp_int = 9;

    *(pp_int +1) = 10;

    *(pp2+1) = 15;

    *(pp2+4) = 12;

     

    for(int i = 0;i < 10;i++)

    {

    cout << *(pp2 + i) << endl;

    }

     

    //动态数组的初始化

    for(int *ppp = pp_int;ppp != pp_int + 10;ppp++)//针对地址++进行值得后移

    {

    *ppp = 11;

    }

    //遍历(指针遍历)

    for(int *pppp = pp_int;pppp != pp_int + 10;pppp++)

    {

    cout << *pppp << endl;

    }

    //普通循环

    for(int i = 0;i < 10;i++)

    {

    cout << *(pp_int + i) << endl;

    }

     

    //const指针,这个指针创建了后就不得修改,所以必须首先对其进行初始化操作

    const int *p_const = new const int[100]();

    //防止内存泄漏

    delete[] p_const;

    delete[] pp_int;

    delete[] p_string;

    delete[] p_dog;

     

    //双引号代表申请了一个空间,存储字符串,const char *pc意思就是开辟一个指针变量

    //相当于pc = &字符串;即获取字符串的地址。

    //c语言的方式

    const char *pc = "a very long literal string";

    cout << pc << endl;

    const size_t len = strlen(pc);

     

    for(size_t ix = 0;ix != 100; ++ix)

    {

    char *pc2 = new char[len+1];

    strcpy(pc2,pc);

    cout << pc2 << endl;

    delete[] pc2;

    }

     

    //c++语言的方式

    string str("a very long literal string");

    //for(int i = 0;i != 100;i++)

    //{

    string str2 = str;

    cout << "c++" << str2 << endl;

    /*}*/

     

     

     

    }

    展开全文
  • C++动态数组的分配

    千次阅读 2019-03-11 20:16:30
    版权声明:【fishing-pan:https://blog.csdn.net/u013921430转载请注明出处】 https://blog.csdn.net/u013921430/article/details/79601429 ...上周,写了一篇《细说C++中的数组之静态数组》,...

    版权声明:【fishing-pan:https://blog.csdn.net/u013921430转载请注明出处】 https://blog.csdn.net/u013921430/article/details/79601429

    【fishing-pan:https://blog.csdn.net/u013921430转载请注明出处】

    1. 前言
      上周,写了一篇《细说C++中的数组之静态数组》,今天讲述一下动态数组。

      数组是一种顺序存储的数据结构,在定义数组时,首先要确定数组的大小。静态数组在编译时就需要确定数组的大小,所以,为了防止内存溢出,我们尽量将数组定义的大一些,但是这样太过浪费内存。

      动态数组则不同,它不需要在编译时就确定大小,它的大小在程序运行过程中确定,所以可以根据程序需要而灵活的分配数组的大小,相比静态数组,它更“灵活”、“自由”。但是动态数组需要进行显式的内存释放。

    2. 动态数组内存分配
      动态数组进行内存分配的格式为new T[size],size可以不是常量表达式;如下面的例子所示。

    int size = 10; //此处的size不是常量表达式。

    int* Dynamic_Arr2 = new int[size]; //未初始化
    可以看出,虽然我们分配了一个动态数组,其实返回的是一个T类型的指针,指针指向的是数组的第一个元素,从这个角度来说,动态数组更像是指针。也是由于这种性质,导致了动态数组中size可以取0,即返回一个空指针,即分配一个空动态数组是合法的。同样的道理,返回的是一个指针,那么就不能使用begin或者end迭代器进行遍历。

    1. 动态数组初始化
      上面的例子中,Dynamic_Arr2并未进行初始化,若想进行默认初始化,需要在数组后面加上一个小括号。

    int* Dynamic_Arr3 = new intsize; //默认的初始化;
    此时数组中的十个值都为0;

     也可以利用花括弧进行显式的初始化,例子如下;
    

    string* Dynamic_Arr4 = new string[size]{“aa”, “bb”,“cc”, “dd”, string(2, ‘e’) }; //显式的初始化
    注意:显式地初始化时,元素数目不能大于数组大小。其次,显式初始化可能会因为编译器版本原因报错,笔者在VS2013与VS2017下进行测试,VS2013下在释放内存时出现内存错误。

    1. 动态数组释放
      释放动态数组时,使用delete[ ] arr_name;即在数组名前加上一个中括弧;例如

    delete [ ] Dynamic_Arr4;
    释放一个动态数组时,或者说是指向数组的指针时,空括号是必须的。它告诉编译器,指针指向一个数组的第一个元素。

     delete释放数组是逆序进行的,最后一个元素被最先释放,第一个元素最后一个被释放。
    
      使用动态数组时,一定要记得显式的释放内存,否则很容易出错,比如在一个大的工程中,某一个for循环中或者某个函数中申请了内存却没释放,当函数不断地被调用,这些申请过的内存会一直堆积,直到最后退出程序。这很可能造成非常大的麻烦。
    

    比如下面两个函数;

    void not_delete_fun()
    {
    int *arr_test = new int[10];

    cout << arr_test << endl;
    
    //delete[] arr_test;
    

    }
    void delete_fun()
    {
    int *arr_test = new int[10];

    cout << arr_test << endl;
    
    delete[] arr_test;
    

    }
    分别调用和释放两个函数三次,看看结果;

      可以看出,释放过内存后,每次数组申请的内存是一致的,未释放内存的函数,每次申请数组的内存是不一样的,说明这些数组申请的内存并不会自动释放,而是会随着程序运行一致累积。
    
    1. 多维动态数组的内存申请
      //-----------------多维数组内存申请-------------------//
      int MAX_NUM = 10;
      int COL_NUM = 5, ROW_NUM = 3;
      double ***Arr3D = new double **[MAX_NUM];

      for (int i = 0; i < MAX_NUM; i++)
      {
      Arr3D[i] = new double *[ROW_NUM];

       for (int j = 0; j < ROW_NUM; j++)
       {
       	Arr3D[i][j] = new double[COL_NUM];
       }
      

      }

      从上面可以看出,多维数组的申请与多维vector的定义类似,是一层一层的申请内存的,返回的是指向指针数组的指针。
      
      
      
      先依次声明维度的大小,然后从最低维度开始申请内存。先申请ROW_NUM个大小为COL_NUM的数组,将指向这些数组的首地址的指针传递到大小为ROW_NUM的数组中,构成一个新的数组,以此类推,完成内存申请。
      

      上面的例子中得到的是一个10层,3行,5列的数组。

    2. 多维动态数组内存释放
      多维动态数组的释放是从最低维度开始的。先释放掉最低维度的一维数组,然后依次释放内存,直到释放掉最高维度。就跟一层一层的拆房子一样。

    for (int i = 0; i < MAX_NUM; i++)
    {
    for (int j = 0; j < ROW_NUM; j++)
    {
    delete[] Arr3D[i][j];
    }
    delete[] Arr3D[i];
    }
    delete[] Arr3D;

    1. 最后
      C++中还提供了allocator类进行动态数组的内存申请,大家可以根据需要自己学习。在此不做讲解。最后附上所有代码,需要的小伙伴可以自行使用。

    #include
    #include
    using namespace std;

    void not_delete_fun()
    {
    int *arr_test = new int[10];

    cout << arr_test << endl;
    
    //delete[] arr_test;
    

    }
    void delete_fun()
    {
    int *arr_test = new int[10];

    cout << arr_test << endl;
    
    delete[] arr_test;
    

    }

    int main()
    {
    int *Dynamic_Arr1 = NULL;
    Dynamic_Arr1 = new int[10];

    int size = 10;
    int *Dynamic_Arr2 = new int[size];       //未初始化;
    
    int *Dynamic_Arr3 = new int[size]{10,9,2,8,3,6,4};     //默认的初始化;
    
    string a = "ee";
    string *Dynamic_Arr4 = new string[size]{"aa", "bb", "cc", "dd", string(1, 'e'), "aa", "bb", "cc", "dd", string(2, 'e')};      //显式的初始化
    //string *Dynamic_Arr4 = new string[size];
    //cout << Dynamic_Arr4[4] << endl;
    
    
    cout << "未释放内存的数组位置" << endl;
    for (int i = 0; i < 3; i++)
    {
    	
    	not_delete_fun();
    	
    }
    cout << "释放过内存的数组位置" << endl;
    for (int i = 0; i < 3; i++)
    {		
    	delete_fun();
    }
    
    //-----------------多维数组内存申请-------------------//
    int MAX_NUM = 10;
    int COL_NUM = 5, ROW_NUM = 3;
    double ***Arr3D = new double **[MAX_NUM];
    
    for (int i = 0; i < MAX_NUM; i++)
    {
    	Arr3D[i] = new double *[ROW_NUM];
    
    	for (int j = 0; j < ROW_NUM; j++)
    	{
    		Arr3D[i][j] = new double[COL_NUM];
    	}
    }
    //cout << Arr3D[9][4][2] << endl;
    
    
    for (int i = 0; i < MAX_NUM; i++)
    {
    	for (int j = 0; j < ROW_NUM; j++)
    	{
    		delete[] Arr3D[i][j];
    	}
    	delete[] Arr3D[i];
    }
    delete[] Arr3D;
    
    
    
    
    delete[] Dynamic_Arr1;
    delete[] Dynamic_Arr2;
    delete[] Dynamic_Arr3;
    delete[] Dynamic_Arr4;
    
    system("pause");
    return 0;
    }
    

    作者:不用先生
    来源:CSDN
    原文:https://blog.csdn.net/u013921430/article/details/79601429
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • C++动态数组的作用

    2020-01-27 17:49:26
    假如要创建一个数组数组长度由用户输入 那就可以这样写: int bufferSize; cin>>bufferSize; int *p=new int[bufferSize]; 但是,如果用静态数组实现这个功能请问怎么实现? int bufferSize; cin>>...

    假如要创建一个数组,数组长度由用户输入
    那就可以这样写:
    int bufferSize;
    cin>>bufferSize;
    int *p=new int[bufferSize];

    但是,如果用静态数组实现这个功能请问怎么实现?
    int bufferSize;
    cin>>bufferSize;
    int arr[bufferSize];吗?系统编译不过的

    静态数组是在堆栈上分配的,在编译的时候就已经确定了大小(VC默认情况下栈大小是1M)
    动态数组存储空间是在上分配的
    只有代码运行的时候才向操作系统申请内存
    机器可用内存有多大,就可以申请多大内存

    静态是说程序还没有运行的时候就决定了,而动态是程序在运行中决定的。

    这里是程序运行时指定需要长度是多少,按需分配,而静态数组是你在程序中就确定好长度,在运行过程中不能改变的。

    比如你有若干组数据处理,在写程序时不确定数据大小,有可能是10,也可能是1000000,这时如果用静态数组就得按照最大分配,分配1000000,但这个程序大多数时候只需处理大小为10的数据,浪费了大量空间。
    有了动态数组(动态内存分配),我们就可以在需要时分配,用完了后释放,大大节省了内存资源。

    展开全文
  • C++动态数组vector实现

    千次阅读 2019-09-03 16:07:34
    最近在做将MATLAB代码转化为C/C++的工作,在实际应用时,发现动态数组非常重要,我在学习的时候也踩了许多坑,这篇就当做一篇踩坑笔记,希望读者能够绕开我踩过的坑,顺利应用动态数组。 1.静态数组动态数组 ...
  • C++ 动态数组(new)

    千次阅读 2020-06-05 00:34:52
    原文链接:动态数组(new) 一、动态数组的定义 数组的维度可以为常量、也可以为一个函数的返回值 int size() { return 3; } const int length = 3; int *p1 = new int[size()]{1,2,3}; int *p2 = new int...
  • c++动态数组怎样申请

    2017-03-29 21:17:09
    用户输入一个数,通过输入的数去动态确定数组的大小。 不能直接在定义数组的时候进行大小声明,而要用指针,返回数组类型的指针。这样就可以先不声明大小,然后等用户输入数组大小之后再确定数组大小。 也不能用...
  • C++学习笔记——C++动态数组的创建与删除

    千次阅读 多人点赞 2016-09-27 10:16:51
    C++中创建动态数组,是用new来实现的type *p = new type [N]当然也可以分开来写type *p1; p1 = new int [N];type是指具体的数据类型, N代表的是一维数组的列数 每次使用new后都要释放delete[] p1; 二、C++创建二...
  • C++动态数组类模板

    千次阅读 2018-03-29 21:55:34
    C和C++学了很久,终于快把基础语法学完了,之后就要进行数据结构和算法的学习,之前写的程序,都是从书上抄下来的,而且很多都是针对着某一个特定的语法,就感觉没有写到博客的必要了,现在学习到了群体类这一块,学...
  • c++动态数组构造及应用

    千次阅读 2011-08-13 18:53:50
    /* 文件名称:arrayclass.h 功能: 自定义数组类型头文件 用于动态数组应用, char类型指针数组 by adengou 2011.8.13 */ //文件头 #ifndef ARRAY_CLASS #define ARRAY_CLASS #i
  • C++动态数组,多重指针问题

    千次阅读 2012-03-05 00:37:34
    今天遇到一个问题,要开辟一个二维指针空间,详细的看了一下网上有关动态指针、动态数组等开辟方法以及学习前辈们对于动态数组问题的解决经验! 一、  首先说明一下多重指针问题,这里解释到第三层,为了方便...
  • 主要介绍了C++字符数组输入输出和符串结束标志使用讲解,是C++入门学习中的基础知识,需要的朋友可以参考下
  • C++ 整型数组连续输入

    2018-09-21 00:36:05
    C++可以使用cin.get()或者cin.getline()输入char型数组。 如果需要输入int 型整数数组怎么办呢? 我知道,已知可以使用循环一个个输入,那么有没有和cin.getline()差不多的流可以输入整型数组啊。
  • C/C++动态数组的创建

    万次阅读 2012-08-15 14:15:13
    C++语言中,二维动态数组主要使用指针的方法建立,以建立一个整数二维数组为例:   #include #include #include using namespace std; int main(int argc,char **argv) {  ///*int a[2][3]={{1,2,3},{4...
  • c++ 动态数组类的创建和简单运用

    千次阅读 2018-09-20 21:15:43
    class ArrayOfPoints{ //动态数组类 public: ArrayOfPoints(int size):size(size){ //构造函数中用动态类存分配的方式,按照初始值size指定的元素个数 分配内存空间 points = new Point[size]; } ~...
  • C++静态数组动态数组的区别

    千次阅读 2015-06-29 15:06:52
    静态数组的长度是固定的,不能根据应用程序的需要改变,而动态内存分配可满足此需求。 比如,你写一个数组用来存放一个班所有人的数学成绩,如果你知道这个班一共有50个人,那好办,直接   int grade...
  • C语言的动态数组 VS C++动态数组

    千次阅读 2018-08-26 19:37:09
    C语言中的动态数组 C语言中的动态数组就是动态内存分配的知识 首先,先看C语言的那些小秘密之动态数组https://blog.csdn.net/bigloomy/article/details/6615012,里面有关内存分配的内容,请看C语言的那些小秘密之...
  • C++字符数组输入输出 在C++中,字符数组输入输出有两种方式 逐个输入输出字符 将整个字符串一次输入或输出 经典案例:C++输出字符串 #include<iostream>//预处理 using namespace std;//命名空间 int ...
  • C/C++ 字符数组输入输出

    万次阅读 多人点赞 2017-02-24 15:09:44
    字符数组输入除了使用scanf外,还可以使用getchar或者gets;其输出除了使用printf外,还可以使用putchar或者puts。 (1)scanf输入,printf输出 scanf对字符串的输入有%s和%c两种格式。%c格式用来输入单个字符,它...
  • C++ 重载 数组对象输入输出流的实现!!! 重载 一个对于c++学习者,必备的技能。简单的来说就是让一些符号依据他们使用对象的不同具有更多重的作用,那为什么说数组的重载呢?,那是因为一下输出多个数组,是不是...
  • C++实现动态数组

    2020-03-31 21:43:57
    C++实现动态数组 1. 数组初始化 2. 给数组赋值 3. 打印数组 4. 增加数组长度 5. 数组最后一个值替代最小值 6. 逆置数组元素 7. 逆置数组中指定位置范围的元素 8. 删除数组中值为x的所有元素 9. 删除所有介于s和t之间...
  • C++实现数组

    2015-12-11 19:44:05
    C++实现数组类,获取数组长度,数组输入数组的输出,数组的复制。
  • C++字符数组输入输出

    千次阅读 2017-08-03 11:13:04
    字符数组输入输出可以有两种方法: 1) 逐个字符输入输出。 2) 将整个字符串一次输入或输出。例如有以下程序段: char str[20]; cin>>str; //用字符数组输入字符串 cout 在运行时输入一个字符串,...
  • C++创建动态数组

    万次阅读 2015-10-25 18:05:41
    这次写的是C++的创建动态数组的小程序,如果学过数据结构的童鞋,看着应该会很省力的,因为这个完全就是数据结构里的动态创建顺序表,几乎一模一样,不太了解的可以先看这里,没学数据结构的童鞋也不用捉急,没有...
  • C++输入数组并进行操作问题C++按从大到小的顺序输入若干个整数,可以有重复,打印输出其中第一大和第二大的数(按从大到小的顺序,把所有重复的数都打印出来)。 C++按从大到小的顺序输入若干个整数,可以有重复,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 247,193
精华内容 98,877
关键字:

c++动态数组输入

c++ 订阅