精华内容
下载资源
问答
  • 下面小编就为大家带来一篇动态数组C++实现方法(分享)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 动态数组C++实现2

    2018-06-19 21:18:21
    C++动态数组二,更方便的分配和使用内存,有赋值构造函数等基本功能函数。。。
  • 动态数组C++实现

    2017-05-23 08:25:00
    数组开始。实现了一个可自动扩充容量的泛型数组。 头文件:Array.h #ifndef Array_hpp #define Array_hpp template <class T> class Array{ private: T *base; //数组首地址 int length; //数组中元素 ...

    回顾大二的数据结构知识。从数组开始。实现了一个可自动扩充容量的泛型数组。

    头文件:Array.h

    #ifndef Array_hpp
    #define Array_hpp
    
    template <class T>
    class Array{
    private:
        T *base;        //数组首地址
        int length;     //数组中元素
        int size;       //数组大小,以数组中元素的大小为单位
    public:
        //初始化数组,分配内存
        bool init();
        //检查内存是否够用,不够用就增加
        bool ensureCapcity();
        //添加元素到数组尾
        bool add(T item);
        //插入元素到数组的具体位置,位置从1开始
        bool insert(int index,T item);
        //删除指定位置的元素并返回,位置从1开始
        T del(int index);
        //返回指定位置的元素
        T objectAt(int index);
        //打印数组所有元素
        void display();
    };
    
    #endif /* Array_hpp */
    

    实现:Array.cpp

    #include "Array.hpp"
    #include <mm_malloc.h>
    #include <iostream>
    using namespace std;
    
    template<typename T> bool Array<T>::init(){    
        base = (T *)malloc(10*sizeof(T));
        if(!base){
            return false;
        }
        size = 10;
        length = 0;
        return true;
    }
    
    template<typename T> bool Array<T>::ensureCapcity(){
        if(length >= size){
            T *newBase = (T*)realloc(base,10 * sizeof(T) + size);
            if(!newBase){
                return false;
            }
            base = newBase;
            size += 10;
            newBase = nullptr;
        }
        return true;
    }
    
    template<typename T> bool Array<T>::add(T item){
        if(!ensureCapcity()){
            return false;
        }
        T *p = base + length;
        *p = item;
        length ++;
        return true;
    }
    
    template<typename T> bool Array<T>::insert(int index,const T item){
        if(!ensureCapcity()){
            return false;
        }
        if(index < 1 || index > length){
            return false;
        }
        T *q = base + index - 1;
        T *p = base + length - 1;
        while( p >= q){
            *(p+1) = *p;
            p--;
        }
        *q = item;
        q = nullptr;
        p = nullptr;
        length ++;
        return true;
    }
    
    template<typename T>T Array<T>::del(int index){
        if(index<1 || index > length){
            return NULL;
        }
        T *q = base + index - 1;
        T item = *q;
        ++q;
        T *p = base + length;
        while(q <= p){
            *(q-1)=*q;
            ++q;
        }
        length --;
        return item;
    }
    
    template<typename T>T Array<T>::objectAt(int index){
        if(index<1 || index > length){
            return NULL;
        }
        T *q = base;
        return *(q + index - 1);
    }
    
    template <typename T>void Array<T>::display(){
        T *q = base;
        T *p = base +length - 1;
        while (q<=p) {
            cout << *(q++)<<" ";
        }
        cout << endl;
    }
    

    使用:

    #include <iostream>
    #include "Array.cpp"
    using namespace std;
    
    int main(int argc, const char * argv[]) {
        Array<int> array = *new Array<int>;
        array.init();
        array.add(1);
        array.insert(1,2);
        array.objectAt(1);
        return 0;
    }

    转载于:https://www.cnblogs.com/jiy-for-you/p/6892358.html

    展开全文
  • 各位大侠 我有一个很长的String,字符串的长度未知,需要将每八个长度为一个数据存到String数组中,怎么处理?
  • C语言的动态数组 VS C++动态数组

    千次阅读 2018-08-26 19:37:09
    C语言中的动态数组 C语言中的动态数组就是动态内存分配的知识 首先,先看C语言的那些小秘密之动态数组https://blog.csdn.net/bigloomy/article/details/6615012,里面有关内存分配的内容,请看C语言的那些小秘密之...

    C语言中的动态数组

    C语言中的动态数组就是动态内存分配的知识

    首先,先看C语言的那些小秘密之动态数组https://blog.csdn.net/bigloomy/article/details/6615012,里面有关内存分配的内容,请看C语言的那些小秘密之内存分配https://blog.csdn.net/bigloomy/article/details/6581706,如果对其中的realloc()函数,malloc()函数,calloc()函数对应里面的eg看不懂的话,可以参考malloc的用法和意义https://blog.csdn.net/chf_1/article/details/78688557这篇blog

     

    C++动态数组的知识主要是new,delete(这俩与内存分配有关)以及vector容器

    参考的blog:C++中如何定义动态数组https://blog.csdn.net/singebogo/article/details/70477737

    C++ 动态数组 vector 详解https://blog.csdn.net/c20182030/article/details/69667965

    顺便强烈推荐:C语言进阶重点、难点与疑点解析。这本书很不错

     

    1.C语言的内存分配有三个函数

    1)realloc()函数

    原型:extern void *realloc(void *mem_address, unsigned int newsize);

    语法:指针名=(数据类型*)realloc(要改变内存大小的指针名,新的大小)。

    头文件:#include <stdlib.h> 有些编译器需要#include <alloc.h>

    功能先按照newsize指定的大小分配空间将原有数据从头到尾拷贝到新分配的内存区域而后释放原来mem_address所指内存区域,同时返回新分配的内存区域的首地址。即重新分配存储器块的地址。

    返回值:如果重新分配成功则返回指向被分配内存的指针,否则返回空指针NULL。

    注意:这里原始内存中的数据还是保持不变的。当内存不再使用时,应使用free()函数将内存块释放。

    2)malloc()函数

    原型:extern void *malloc(unsigned int num_bytes);

    头文件:在Visual C++6.0中可以用malloc.h或者stdlib.h

    功能分配长度为num_bytes字节的内存块

    返回值:如果分配成功则返回指向被分配内存的指针,否则返回空指针NULL。当内存不再使用时,应使用free()函数将内存块释放。

    说明:该函数返回为void型指针,因此必要时要进行类型转换。(这就是为啥要在malloc函数之前加强制类型转换)

    3)calloc()函数

    calloc是一个C语言函数

    功 能: 在内存的动态存储区中分配n个长度为size的连续空间,函数返回一个指向分配起始地址的指针;如果分配不成功,返回NULL。

    跟malloc的区别:

    calloc在动态分配完内存后,自动初始化该内存空间为零,而malloc不初始化,里边数据是随机的垃圾数据。

    用 法: void *calloc(unsigned n,unsigned size);

    头文件:stdlib.h或malloc.h

     

    重头戏

    C语言动态数组

    动态数组的内存空间是从堆动态分配的,是通过执行代码而为其分配存储空间。当程序执行到我们编写的分配语句时,才为其分配。对于静态数组,其创建非常方便,使用完也无需释放,要引用也简单,但是创建后无法改变其大小是其致命弱点!对于动态数组,其创建麻烦,使用完必须由程序员自己释放,否则将会引起内存泄露。但其使用非常灵活,能根据程序需要动态分配大小。所以相对于静态数组的来说我们对于使用动态数组有很大的自由度。

    在创建动态数组的过程中我们要遵循一个原则,那就是在创建的时候从外层往里层,逐层创建;而释放的时候从里层往外层,逐层释放

    那篇blog中讲解了一维动态数组、二维动态数组、以及三维动态数组的创建与释放,由于一维和二维用的比较多,所以我着重看一下这俩,三维的话看兴趣吧,目前找工作要紧,所以就不太深入

    一维动态数组的创建:

    主要还是calloc()、malloc()、realloc()函数创建动态空间

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
    int n1,i;
    int *array;
    printf("请输入所要创建的一维动态数组的长度:");
    scanf("%d",&n1);
    array=(int*)calloc(n1,sizeof(int));
    for(i=0;i<n1;i++)
    {
     printf("%d\t",array[i]);
    }
    printf("\n");
    for(i=0;i<n1;i++)
    {
     array[i]=i+1;
     printf("%d\t",array[i]);
    }
     free(array);//释放第一维指针 
    return 0;
    }

    运行结果为:

    特此说明:在以后的运行结果部分,我均会附上文字结果,以防图片打开失败。

    请输入所要创建的一维动态数组的长度:4
    0       0       0       0
    1       2       3       4       Press any key to continue

    在此我使用的是calloc()函数来分配的,同时也使用两个for语句来打印数组元素,我们发现第一个打印输出的数组元素值均为0,在此也是为了加深读者对于calloc()函数的印象我特地使用了它来分配

     

    二维数组的创建(需要双重指针):

    #include <stdio.h> 
    #include <stdlib.h> 
    int main() 
    { 
    int n1,n2; 
    int **array,i,j; 
    printf("请输入所要创建的动态数组的第一维长度:");
    scanf("%d",&n1);
    printf("请输入所要创建的动态数组的第二维长度:");
    scanf("%d",&n2); 
    array=(int**)malloc(n1*sizeof(int*)); //第一维 
    for(i=0;i<n1; i++) 
    { 
    array[i]=(int*)malloc(n2* sizeof(int));//第二维 
    }
    for(i=0;i<n1;i++)
    {
    for(j=0;j<n2;j++) 
    { 
    array[i][j]=i*n2+j+1; //i是行,j是列,注意观察数据的行列之间的关系,就可以懂了
    printf("%d\t",array[i][j]); 
    } 
    printf("\n");
    }
    for(i=0;i<n1;i++) 
    { 
    free(array[i]);//释放第二维指针 
    } 
    free(array);//释放第一维指针 
    return 0; 
    }

    运行结果为:

     请输入所要创建的动态数组的第一维长度:3
    请输入所要创建的动态数组的第二维长度:3
    1       2       3
    4       5       6
    7       8       9
    Press any key to continue

    有了上面的代码我们再来说动态数组的建立就简单了,以二维为例,先说创建,还记得我们上面说的创建的原则嘛:从外层往里层,逐层创建。

    array=(int**)malloc(n1*sizeof(int*)); //第一维

    以上是我们创建二维动态数组的最外层,创建好了最外层那么我们接下来就是要创建次外层了。

    array[i]=(int*)malloc(n2* sizeof(int));//第二维

    在创建次外层的过程中我们使用了一个for循环语句,千万别忘了使用for循环语句,这是绝大多数人的一个易错点。

    创建好了接下来我们该讲到释放了,而释放的时候从里层往外层,逐层释放。刚刚与我们上面的创建相反,在以上代码中我们首先使用了下面一个for循环来释放里层。

    for(i=0;i<n1;i++) 

    free(array[i]);//释放第二维指针 
    }

    在通过以下语句来释放外层。
    free(array);//释放第一维指针

    ================================================================================================

     

    C++语言中的动态数组

     

    c++要求定义数组时,必须明确给定数组的大小,要不然编译通不过 

      如: int Array[5];正确

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

    所以,new 动态定义数组来解决定义长度未知的数组。

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

     

    二维动态数组的定义
      int size=50
      int (*p)[50]=new int [size][50]
      便正确了。

    由此可见,这种动态分配数组,仅对一维数组空间是真正动态分配的。

    既然一维是真正的动态分配的话,那我们利用这一特性定义一个指针数组。
       
       int **p= new int*[size];//定义指针数组 
       int *p[5];//  假若知道二维数组的行数为5

    注意:指针数组定义了size个int型指针变量,用来存储地址

       然后对指针数组中的每一个指针分配一个一维数组空间,这样便动态定义了二维数组
      
       事实上,我认为指针数组的主要用途,就在于动态定义多维数组
        
        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];
    }

    所生成的动态数组如下图所示:(6行5列)

     

    最后 ,因为调用了new, 千万千万别忘记在用完之后,将其所占资源 delete 掉
    
     
    
      下面是delete方法:
    
        for(int i=0;i<size;i++)
       {
    
               delete []  p[i];   // 要在指针前加[] , 否则的话 只释放p[i]所指的第一个单元所占的空间
       }
    
     
    
       delete [] p;     //最后不要忘掉 释放掉开辟的指针数组  :》

     

    动态数组vector的具体用法,参考我最上面说明的blog,我只对我理解的关键点进行相应解释

    1,首先它所提出的代码,结果为啥是这样的?

    可以看出vector的内存是翻倍了,这就是vector容器的特点吧,对于size从3到5的解释是:这时候新增加一个i=4,所以这个时候v=[1,2,3,4],而前面的last=4,所以不执行if语句了,新的i=5,所以这个时候v=[1,2,3,4,5],而capacity翻倍了a=8,而8不等于这个4,所以就输出了,得到此时size()=5的结果。

     

    与此同时,blog作者经过其它的实验,为啥得出下面的结论的原因,两个结合看,事半功倍

    当动态数组内的元素比动态数组长度多一时,动态数组长度翻倍!

    也就是说:if(v.size()-1==v.capacity()) v.resize(v.capacity()*2);

    eg:size()=5-1等于capacity=4的时候,capacity翻倍为8了

    blog作者的建议是:

    而长度翻倍是很花时间的。所以说做题的时候,记得事先把vector的长度拉得足够长,以免运行的时候,vector长度翻倍浪费时间。

     

     

     

    展开全文
  • 返回 C++小白入门cplusplus 官网 vector【介绍】动态数组vector是C语言数组的动态版本,其目标是可以操持C语言数组下标访问元素的效率的同时,不需要一开始固定容器大小;在vector内部,我们可以假设元素是连续存放...

    返回 C++小白入门

    cplusplus 官网 vector

    【介绍】动态数组vector是C语言数组的动态版本,其目标是可以操持C语言数组下标访问元素的效率的同时,不需要一开始固定容器大小;在vector内部,我们可以假设元素是连续存放的;元素可以在执行过程中不断的添加;删除中间的任意元素可以认为都是低效率的,因为会涉及到后续元素的移动;

    【创建数组】vector是准备取代C语言数组的一个标准库类型。

    vector

    【访问元素】vector最大的特点是可以用常量时间访问任意位置的元素:

    int i = arr[58];//将下标位置为58的元素值赋值给整型变量i

    【添加元素】到vector可以使用push_back(i)方法:

    arr.push_back(i);//arr的末尾新增了一个元素

    【元素数量】当前容器有多少元素size()

    int c = arr.size();//获取数组元素数量存到c中

    【判断空】当前容器是不是一个元素也没有的空数组:

    bool e = arr.empty();//如果元素个数为0,就返回true

    【遍历】使用下标遍历:

    for(int i = 0; i < arr.size(); ++i)
    {
        cout<<arr[i]<<endl;//使用下标访问元素
    }

    【遍历】使用迭代器遍历:

    for(auto itr = arr.begin(); itr != arr.end(); ++itr)
    {
        cout<<*itr<<endl;//使用迭代器的解引用操作获取元素的引用
    }

    【遍历】使用C++11 范围for循环:

    for(auto& i  :  arr)
    {
        cout<<i<<endl;//使用范围for循环遍历元素
    }

    【示例代码】

    #include 

    8bf5f873e5d02da0813c93c8fc6d38f4.png

    返回 C++小白入门

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

    2017-06-02 14:36:42
    通过动态分配的方法实现了动态数组的创建,其中包括多种运算符重载。
    
    

    通过动态分配的方法实现了动态数组的创建,其中包括多种运算符重载。

    #include 
    #define SIZE 100
    using namespace std;
    
    template 
    class Array {
    private:
        T *m_data;
        int length;//数组长度
    public:
        //无参构造函数
        Array() {
            length = 0;
            m_data = new T[SIZE];
        } //有参构造函数,参数为数组的长度
        Array(int n) : length(n) {
            m_data = new T[length];
        } //有参构造函数,参数为数组的长度和初始化元素
        Array(int n, T x) : length(n) {
            m_data = new T[length];
            for (int i = 0; i < length; i++)
                m_data[i] = x;
        } //拷贝构造函数
        Array(const Array &rhs) {
            length = rhs.length;
            m_data = new T[length];
            for (int i = 0; i < length; i++)
                m_data[i] = rhs.m_data[i];
        } //析构函数
        ~Array() {
            length = 0;
            delete[] m_data;
        } //返回数组长度
        int size() const {
            return length;
        } //重载+运算符
        Array operator+(Array &rhs) {
            Array sum;
            if (this->length > rhs.length)
                sum.length = rhs.length;
            else
                sum.length = this->length;
            for (int i = 0; i < sum.length; i++)
                sum.m_data[i] = this->m_data[i] + rhs.m_data[i];
            return sum;
        } //重载-运算符
        Array operator-(Array &rhs) {
            Array sub;
            if (this->length > rhs.length)
                sub.length = rhs.length;
            else
                sub.length = this->length;
            for (int i = 0; i < sub.length; i++)
                sub.m_data[i] = this->m_data[i] - rhs.m_data[i];
            return sub;
        } //重载==运算符
        bool operator==(Array &rhs) {
            int count = 0;
            if (length == rhs.length) {
                for (int i = 0; i < length; i++) {
                    if (m_data[i] == rhs.m_data[i])
                        count++;
                }
                if (count == length)
                    return true;
                else
                    return false;
            } else
                return false;
        } //重载[]运算符
        int &operator[](int index) {
            if (index < 0 || index >= length)
                throw "invalid index";
            return m_data[index];
        } //重载=运算符
        void operator=(Array &rhs) {
            length = rhs.length;
            for (int i = 0; i < length; i++)
                m_data[i] = rhs.m_data[i];
        } //输出运算符<<
        friend ostream &operator<<(ostream &output, const Array &rhs) {
            for (int i = 0; i < rhs.length; i++)
                output << rhs.m_data[i] << " ";
            return output;
        } //输入运算符>>
        friend istream &operator>>(istream &input, Array &rhs) {
            while (input >> rhs.m_data[rhs.length]){rhs.length++;}
            return input;
        }
    };
    
    int main()
    {
        try {
            Array a1;
            cout << "Please input a1: ";
            cin >> a1;
            cout << "a1: " << a1 << endl;
            a1[0] = 5, a1[1] = 6;
            cout << "a1: " << a1 << endl;
            Array a2(a1);
            cout << "a2: " << a2 << endl;
            Array a3 = a2;
            cout << "a3: " << a3 << endl;
            cout << "a1 == a2 " << (a1 == a2) << endl;
            cout << "a2 == a3 " << (a2 == a3) << endl;
            Array a4 = a1 + a2 - a3;
            cout << "a4: " << a4 << endl;
        } catch (const char *msg) {
            cout << msg << endl;
        }
        return 0;
    }

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

    万次阅读 多人点赞 2018-10-18 13:51:30
    注意:静态数组是在堆栈上(不需要自行释放空间)创建,动态数组是在堆上创建(需要自行释放空间) 涉及内容: 堆(heap)-自由存储区(free store) C语言:malloc和free c++语言:new和delete 1.动态数组定义...
  • //一维数组,a被C++编译器解释为指针常量int b[3][4];//二维数组,其本质是线性的一维数组二维数组b在内存中是线性顺序,各元素相邻存储,其地址自然也是线性关系。如果第一维下标用i表示,第二维用j表示,则其元素...
  • C++动态数组

    2014-04-24 12:11:21
    详细的C++动态数组的使用讲解,指针数组、动态数组等多种方法
  • 动态数组 学习C++的经典例子000
  • 返回 C++小白入门cplusplus 官网 vector【介绍】动态数组vector是C语言数组的动态版本;其目标是可以操持C语言数组下标访问元素的效率的同时,不需要一开始固定容器大小;在vector内部,我们可以假设元素是连续存放...
  • 接着跟大家更新c++入门教程:c++中的动态数组C++的new操作符是该语言一个非常好的语法特性,然而实际使用中却发现new操作符有不少限制,为突出的一点便是用new操作符分配多维数组空间时,不能让数组的每一维都动态可...
  • 动态分配二维数组 C++

    2020-02-06 17:00:04
    动态分配二维数组 1)采用指针的指针 T** 2)指针的指针指向一片存放指针数组作为行 3)指针数组中每一个元素都指向一个元素数组作为列 例如: int main(){ int h, l; cin >> h >> l; int **ptr; //...
  • 动态数组封装成类[1]更加简洁,便于管理可以在访问数组元素前检查下标是否越界例6-18 动态数组类#include 运行结果:ArrayOfPoints这个类中,它的数据成员没有数组,只有一个指向point类型对象的指针和数组元素个...
  • list对象是一种 容量自适应的 线性容器,底层由 动态数组实现。动态数组结构决定了 list对象具有优秀...现成的动态数组实现很多,除了我们正在研究的list对象,C++ 中的 vector 也是众所周知。虽然在实际项目中需要...
  • 定义一元素为整数的动态数组类,并在主函数中调用各个功能: 数据成员:指向元素首地址的指针(用于存储动态申请的数组空间)、当前数组的容量、当前元素的个数; 成员函数: 带参/无参构造函数(无参的动态申请10个...
  • 问题在写程序时有时候需要定义一个长度为n的数组,但n是一个变量 在C语言中一定不可以这样写: #include C语言中无法动态定义一个数组长度[^1]解决思路可以向计算机申请一个长度为n的内存代码如下 一维动态数组的...
  • 动态数组C++、Java)

    2020-08-05 19:41:55
    动态数组 **C++**版 参考自李嘉信(博客园) //以下为错误用法,因为数组的长度必须为常量值 //C++为编译型语言,编译阶段只进行查语法错误和预分配空间,并没有执行"size = 1"这个赋值语句 int size = 1; int ...
  • 动态数组c++

    2013-11-21 17:33:52
    相信很多朋友们在建立数组的时候,都会给一个100的长度,因为无法确定数组的上限,只能预留大量内存,进而降低了系统的性能,而动态数组解决了这个问题。  下面是动态数组一个简单的小程序:  #include #include /...
  • 两维的动态数组C++封装
  • 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++入门教程:c++中的动态数组 C++的new操作符是该语言一个非常好的语法特性,然而实际使用中却发现new操作符有不少限制,为突出的一点便是用new操作符分配多维数组空间时,不能让数组的每一维都动态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,379
精华内容 4,151
关键字:

动态数组c++

c++ 订阅