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

    2020-10-15 10:08:18
    C语言动态数组一、动态数组1.动态数组介绍1.具体思路二、程序1.代码1.运行结果 一、动态数组 1.动态数组介绍 在实际的编程中,往往会发生这种情况,即所需的内存空间取决于实际输入的数据,而无法预先确定。对于...

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    一、动态数组

    1.动态数组介绍

    在实际的编程中,往往会发生这种情况,即所需的内存空间取决于实际输入的数据,而无法预先确定。对于这种问题,用静态数组的办法很难解决。为了解决上述问题,C语言提供了一些内存管理函数,这些内存管理函数结合指针可以按需要动态地分配内存空间,来构建动态数组,也可把不再使用的空间回收待用,为有效地利用内存资源提供了手段。

    动态数组,是相对于静态数组而言。静态数组的长度是预先定义好的,在整个程序中,一旦给定大小后就无法改变。而动态数组则不然,它可以随程序需要而重新指定大小。动态数组的内存空间是从堆(heap)上分配(即动态分配)的。是通过执行代码而为其分配存储空间。当程序执行到这些语句时,才为其分配。程序员自己负责释放内存。

    1.具体思路

    我们可以在堆区申请一块数组内存空间,当我们申请的内存不够用的时候,可以在堆区再开辟一块新的数组,将旧数组的元素放到新数组中,释放旧数组,最后再插入新元素。

    二、程序

    1.代码

    #include <iostream>
    #include "./dynamic_array.h"
    using namespace std;
    
    class DynamicArray
    {
    
    private:
        int m_capacity_; //容量
        int m_size_;     //长度
        int *m_data_;
    
    public:
        DynamicArray(int input_capacity);
        ~DynamicArray();
        void insert(int index, int value);
        void expand(void);
        void remove_index(int index);
        void remove_value(int value);
        void print(void);
        int get_size(void);
        int get_capacity(void);
    };
    
    //构造
    DynamicArray::DynamicArray(int input_capacity)
    {
        m_capacity_ = input_capacity;
        m_size_ = 0;
        m_data_ = new int[m_capacity_];
    }
    
    //析构
    DynamicArray::~DynamicArray()
    {
        delete[] m_data_;
        m_data_ = NULL;
    }
    
    //插入元素
    void DynamicArray::insert(int index, int value)
    {
        if (index < 0 || index > m_size_)
        {
            return;
        }
        if (m_size_ >= m_capacity_)
        {
            expand();
        }
        for (int i = m_size_; i > index; i--) //后移元素
        {
            m_data_[i] = m_data_[i - 1];
        }
        m_data_[index] = value;
        m_size_++;
        return;
    }
    
    //扩展数组
    void DynamicArray::expand(void)
    {
        int *old_data = m_data_;
    
        //容量*2后,开辟新空间
        m_capacity_ *= 2;
        m_data_ = new int[m_capacity_];
        for (int i = 0; i < m_size_; i++)
        {
            m_data_[i] = old_data[i];
        }
        delete[] old_data;
        old_data = NULL;
    }
    
    //删除元素
    void DynamicArray::remove_index(int index)
    {
        if (index < 0 || index >= m_size_)
        {
            return;
        }
        for (int i = index + 1; i < m_capacity_; i++)
        {
            m_data_[i - 1] = m_data_[i];
        }
        m_size_--;
    }
    
    //按值删除元素
    void DynamicArray::remove_value(int value)
    {
        for (int i = 0; i < m_capacity_; i++)
        {
            if (value == m_data_[i])
            {
                for (int j = i + 1; j < m_capacity_; j++)
                {
                    m_data_[j - 1] = m_data_[j];
                }
                m_size_--;
                return;
            }
        }
    }
    
    //打印数据
    void DynamicArray::print(void)
    {
        for (int i = 0; i < m_size_; i++)
        {
            if (i > 0)
            {
                cout << " ";
            }
            cout << m_data_[i];
        }
        cout << endl;
    }
    
    //返回长度
    int DynamicArray::get_size(void)
    {
        return m_size_;
    }
    
    //返回容量
    int DynamicArray::get_capacity(void)
    {
        return m_capacity_;
    }
    
    int main(int argc, char const *argv[])
    {
        DynamicArray arr(10);
    
        arr.insert(0, 1);
        arr.insert(8, 2);
        arr.insert(0, 5);
        arr.insert(0, 7);
        arr.insert(0, 4);
        cout << "删除前长度:" << arr.get_size() << endl;
        arr.print();
        arr.remove_index(0);
        arr.remove_value(5);
        cout << "删除后长度:" << arr.get_size() << endl;
        arr.print();
        return 0;
    }
    
    

    1.运行结果

    删除前长度:4
    4 7 5 1
    删除后长度:2
    7 1
    
    
    展开全文
  • 主要介绍了C语言动态数组的使用实现代码的相关资料,需要的朋友可以参考下
  • C语言动态数组数据类型(动态数组库)动态数组库功能设计源文件、具体实现测试程序和运行结果 动态数组库功能设计 静态数组一经创建大小不能改变。动态数组更灵活,可以在程序运行时根据需要指定数组大小。 这个...

    C语言动态数组数据类型(动态数组库)


    动态数组库功能设计

    静态数组一经创建大小不能改变。动态数组更灵活,可以在程序运行时根据需要指定数组大小。
    利用C语言实现抽象数据类型(ADT)的方法C语言实现抽象数据类型(ADT),实现动态数组数据类型。
    这个动态数组功能有:

    1. 从头部插入元素;从尾部插入元素;根据下标访问、插入、删除元素等。
    2. 可用回调函数遍历动态数组。

    以下是头文件dynints.h

    #ifndef DYNINTS_H
    #define DYNINTS_H
    
    struct DYNINTS;
    typedef struct DYNINTS * PDYNINTS;
    
    /*创建动态数组,参数是数组元素最大个数,返回动态数组指针*/
    PDYNINTS create_dynints(int capacity);
    /*在头部插入元素*/
    void insert_head(PDYNINTS di_array, int element);
    /*在尾部插入元素*/
    void insert_tail(PDYNINTS di_array, int element);
    /*根据下标插入元素,index参数为下标值*/
    void insert_by_index(PDYNINTS di_array, int element, int index);
    /*返回数组元素个数*/
    int array_length(PDYNINTS di_array);
    /*判断是否为空,空返回1*/
    bool Is_empty(PDYNINTS di_array);
    /*根据下标访问元素,模拟C语言,C语言没有引用,只能返回地址*/
    int * access_by_index(PDYNINTS di_array, int index);
    /*根据下标删除元素*/
    void delete_by_index(PDYNINTS di_array, int index);
    /*数组的复制(已有一个普通数组array),参数为数组名称和元素个数。*/
    void duplicate_array(PDYNINTS di_array, int * array, int count);
    /*销毁动态数组*/
    void destroy_array(PDYNINTS di_array);
    /*func回调函数遍历动态数组*/
    void travel_array(PDYNINTS di_array, void (*func)(int * data));
    
    #endif
    

    源文件、具体实现

    1. 这里是用memcpy内存复制函数进行动态数组更新的。其函数原型为void *memcpy(void *destin, void *source, unsigned n),要注意参数填写正确。我记得我第一次写的时候把函数指针运算的结果和地址概念搞错了:假设p是一个T *类型的指针,而n是一个整型变量或常量,那么p+n是一个类型为T *类型的指针变量,它指向的地址是p + n × sizeof(T)。填入memcpy的前两个参数应该是指针变量。有时有的书上会把指针、指针变量、地址混起来说,比较容易混淆。指针可以等价于地址,指针变量是存储地址的变量。但经常把指针变量P直说成指针P
    2. 回调函数是个好东西,在测试程序中简单用个输出函数来测试回调函数遍历动态数组的。
    3. 我是用new和delete写的,没用malloc、free。用在这里没区别。new和delete用在C++的对象上会调用构造函数析构函数。new和delete底层也是通过malloc和free实现的。malloc和free是函数,new和delete是运算符,可以重载new和delete以实现自己的内存管理策略。

    dynints.cpp

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <cstdlib>
    #include "dynints.h"
    
    using namespace std;
    
    struct DYNINTS{
        int capacity; //最大容量
        int count;  //实际存储了多少个
        int *items;  //动态数组指针
        bool modified;  //数组是否被修改,这没啥用
    };
    
    /*创建动态数组,参数是数组元素最大个数,返回动态数组指针*/
    PDYNINTS create_dynints(int capacity)
    {
        PDYNINTS di_array = new DYNINTS;
        if (di_array == NULL) {
            printf("动态内存分配失败!\n");
            exit(1);
        }
    
        di_array->capacity = capacity;
        di_array->count = 0;
        di_array->items = NULL;
    
        return di_array;
    }
    
    /*在头部插入元素*/
    void insert_head(PDYNINTS di_array, int element)
    {
        if (di_array->count >= di_array->capacity) {
            printf("数组已达到最大容量。\n");
            exit(2);
        }
    
        int *temp = new int[(di_array->count + 1) * sizeof(int)];
        if (temp == NULL) {
            printf("动态内存分配失败!\n");
            exit(1);
        }
    
        memcpy(temp, &element, sizeof(int));
        memcpy(temp + 1, di_array->items, di_array->count * sizeof(int));
        if (!Is_empty(di_array))
            delete [] di_array->items;//if用来防止数组原来就是空的。
        di_array->count++;
        di_array->items = temp;
        di_array->modified = true;
    }
    
    /*在尾部插入元素*/
    void insert_tail(PDYNINTS di_array, int element)
    {
        if (di_array->count >= di_array->capacity) {
            printf("数组已达到最大容量。\n");
            exit(2);
        }
    
        int *temp = new int[(di_array->count + 1) * sizeof(int)];
        if (temp == NULL) {
            printf("动态内存分配失败!\n");
            exit(1);
        }
    
        memcpy(temp, di_array->items, di_array->count * sizeof(int));
        memcpy(temp + di_array->count, &element, sizeof(int));
        if (!Is_empty(di_array))
            delete [] di_array->items;
        di_array->count++;
        di_array->items = temp;
        di_array->modified = true;
    }
    
    /*根据下标插入元素,index参数为下标值*/
    void insert_by_index(PDYNINTS di_array, int element, int index)
    {
        if (di_array->count >= di_array->capacity) {
            printf("数组已达到最大容量。\n");
            exit(2);
        }
    
        if (index < 0 || index >= di_array->count) {
            printf("下标值非法。\n");
            exit(3);
        }
    
        int *temp = new int[(di_array->count + 1) * sizeof(int)];
        if (temp == NULL) {
            printf("动态内存分配失败!\n");
            exit(1);
        }
    
        memcpy(temp, di_array->items, index * sizeof(int));
        memcpy(temp + index, &element, sizeof(int));
        memcpy(temp + (index + 1), di_array->items + index, (di_array->count - index) * sizeof(int));
        if (!Is_empty(di_array))
            delete [] di_array->items;
        di_array->count++;
        di_array->items = temp;
        di_array->modified = true;
    }
    
    /*返回数组元素个数*/
    int array_length(PDYNINTS di_array)
    {
        return di_array->count;
    }
    
    /*判断是否为空,空返回1*/
    bool Is_empty(PDYNINTS di_array)
    {
        return di_array->count == 0 && di_array->items == NULL;
    }
    
    /*根据下标访问元素,模拟C语言,C语言没有引用,只能返回地址*/
    int * access_by_index(PDYNINTS di_array, int index)
    {
        if (index < 0 || index >= di_array->count) {
            printf("下标值非法。\n");
            exit(3);
        }
    
        return di_array->items + index;
    }
    
    /*根据下标删除元素*/
    void delete_by_index(PDYNINTS di_array, int index)
    {
        if (index < 0 || index >= di_array->count) {
            printf("下标值非法。\n");
            exit(3);
        }
    
        int * temp = new int[(di_array->count - 1) * sizeof(int)];
        if (temp == NULL) {
            printf("动态内存分配失败!\n");
            exit(1);
        }
    
        memcpy(temp, di_array->items, index * sizeof(int));
        memcpy(temp + index, di_array->items + (index + 1), (di_array->count - 1 - index) * sizeof(int));
        delete [] di_array->items;
        di_array->count--;
        di_array->items = temp;
        di_array->modified = true;
    }
    
    /*数组的复制(已有一个普通数组),参数有数组名称和数组个数。*/
    void duplicate_array(PDYNINTS di_array, int * array, int count)
    {
        if (di_array->capacity < count) {
            printf("超过了数组最大容量。\n");
            exit(2);
        }
    
        if (!Is_empty(di_array)) {
            delete [] di_array->items;
            di_array->count = 0;
        }
    
        di_array->items = new int[count * sizeof(int)];
        if (di_array->items == NULL) {
            printf("动态内存分配失败!\n");
            exit(1);
        }
        memcpy(di_array->items, array, count * sizeof(int));
        di_array->count = count;
        di_array->modified = true;
    }
    
    /*销毁动态数组*/
    void destroy_array(PDYNINTS di_array)
    {
        delete di_array->items;
        delete di_array;
        di_array = NULL;
    }
    
    /*func回调函数遍历动态数组*/
    void travel_array(PDYNINTS di_array, void (*func)(int * data))
    {
        for (int i = 0; i < di_array->count; ++i)
            func(di_array->items + i);
    }
    
    

    测试程序和运行结果

    main.cpp

    #include <iostream>
    #include <cstdio>
    #include "dynints.h"
    
    using namespace std;
    
    void print_array(int * data)//回调函数
    {
        printf("%d ", *data);
    }
    
    int main(void)
    {
        int ARRAY[5] = {1,2,3,4,5};
        PDYNINTS my_array = create_dynints(9);
    
        printf("把【1,2,3,4,5】复制到动态数组:\n");
        int count = (int) (sizeof(ARRAY) / sizeof(ARRAY[0]));
        duplicate_array(my_array, ARRAY, count);
        travel_array(my_array, print_array);
        printf("\n");
    
        printf("在头部插入0:\n");
        insert_head(my_array, 0);
        travel_array(my_array, print_array);
        printf("\n");
    
        printf("在尾部插入6:\n");
        insert_tail(my_array, 6);
        travel_array(my_array, print_array);
        printf("\n");
    
        printf("在下标为5的元素插入7:\n");
        insert_by_index(my_array, 7, 5);
        travel_array(my_array, print_array);
        printf("\n");
    
        printf("Now the dynamic array has %d elements.\n", array_length(my_array));
    
        printf("把下标为2的元素改成10:\n");
        int * p_element = access_by_index(my_array, 2);
        *p_element = 10;
        travel_array(my_array, print_array);
        printf("\n");
    
        printf("把下标为4的元素删除:\n");
        delete_by_index(my_array, 4);
        travel_array(my_array, print_array);
        printf("\n");
    
        destroy_array(my_array);
    
        return 0;
    }
    

    运行结果:
    在这里插入图片描述

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

    2015-05-31 13:36:25
    总是在c语言程序中遇到数组动态分配的问题 难点在于c语言并不支持动态数组的分配 所有的变量赋值都必须在程序编译阶段完成 而有时程序的数组长度并不知道 所以这时就要用指针动态分配内存来解决这个问题 ...

    总是在c语言程序中遇到数组动态分配的问题 难点在于c语言并不支持动态数组的分配 所有的变量赋值都必须在程序编译阶段完成 而有时程序的数组长度并不知道 所以这时就要用指针动态分配内存来解决这个问题
    下面是一个动态分配一维数组的程序:

     #include <stdio.h>
     #include<stdlib.h>
    int main()
    {
      int num,*p=0,i;
      printf("输入数组元素个数:");
      /*输入数组元素个数,保存到变量num中*/
      scanf("%d",&num);
      /*动态分配数组存储空间*/
      p = (int *)malloc(sizeof(int)*num);
      /*输入数据*/
      for(i=0;i<num;i++)
      {
          scanf("%d",&p[i]);
      }
      /*输出数据*/
      for(i=0;i<num;i++)
      {
          printf("%d ",p[i]);
      }
      /*删除动态创建的数组*/
      free(p);
      p=null;
    return 0;
    }

    最后要释放指针 防止内存泄漏

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

    2016-01-14 10:33:00
    C语言中,在声明数组时,必须明确告诉编译器数组的大小,之后编译器就会在内存中为该数组开辟固定大小的内存。有些时候,用户并不确定需要多大的内存,使用多大的数组,为了保险起见,有的用户采用定义一个大数组的...

    C语言中,在声明数组时,必须明确告诉编译器数组的大小,之后编译器就会在内存中为该数组开辟固定大小的内存。有些时候,用户并不确定需要多大的内存,使用多大的数组,为了保险起见,有的用户采用定义一个大数组的方法,开辟的数组大小可能比实际所需大几倍甚至十几倍,这造成了内存的浪费,带来了极大的不便。另一方面,即使用户确切知道要存放的元素个数,但随着问题的深入,元素数目可能会变化,变少还好处理,可如果数目增加呢,用什么来存储的,类似于数组内存这种分配机制就称为静态分配,很明显,静态分配是由编译器完成的,在程序执行前便已指定。显而易见,静态分配虽然直观,易理解,但存在明显的缺陷,不是容易浪费内存就是内存不够用,为解决这一问题,C语言引入了动态分配机制。
    C语言函数库中提供了malloc和free函数,允许用户用户调用以动态申请说需要的内存,给程序的设计带来了很大的灵活性。(引用尹成的ppt)

    现在我们来创建一个动态大小的数组

    #include<stdio.h>
    #include<stdlib.h>
    
    //内存释放完成以后必须释放
    //分配动态数组
    
    void main(){
        int num = 10;
        int *p = malloc(num * sizeof(int));
        printf("%x", p);//打印内存地址
        for (int i = 0; i < num; i++)
        {
            printf("\n%d", p[i] = i + 1);
        }
        //内存释放完成以后必须释放
        free(p);
        system("pause");
    }

     

    #include<stdio.h>
    #include<stdlib.h>
    
    //内存释放完成以后必须释放
    //分配动态数组
    
    void main(){
        //calloc需要两个参数以指定申请内存块的大小,第一个参数一种数据结构的个数,第二个参数是单个数据结构的大小。
    //注意:malloc一般不会初始化系统分配的内存块,通常需要使用memset()函数来初始化,而calloc()函数会初始化系统分配的内存块,将所有的位(bit)置零。
    //calloc一般使用后要使用 free(起始地址的指针) 对内存进行释放,不然内存申请过多会影响计算机的性能, //以至于得重启电脑。如果使用过后不清零,还可以使用指针对该块内存进行访问。 int *p = (int *)calloc(50,sizeof(int));//动态分配 for (int i = 0; i < 50; i++) { printf("\n%d", p[i] = i + 2); } printf("\n%x", p); printf("*******************************\n"); //realloc将原有数据从头到尾拷贝到新分配的内存区域,而后释放原来mem_address所指内存区域 //(注意:原来指针是自动释放,不需要使用free),同时返回新分配的内存区域的首地址。 //realloc会把释放的内存拷贝到新地址, //新的大小可大可小(但是要注意,如果新的大小小于原内存大小,可能会导致数据丢失,慎用!) int *p1 = realloc(p, sizeof(int)* 75); printf("\n%x", p1); printf("*******************************\n"); for (int i = 0; i < 75; i++) { printf("\n%d", p1[i]); } //当内存不再使用时,应使用free()函数将内存块释放。 free(p1); //通过最终结果观察可知,通过realloc函数在calloc函数的内存上所新分配的内存其实首地址是一样的, //即p的值和p1的值是一样的 //好像内存机制并不是复制calloc函数的内存,而是在calloc函数的内存的基础上又申请了一段 system("pause"); }

     

     

    展开全文
  • c语言动态数组示例

    2020-09-04 11:33:39
    是一个简单的动态分配数组大小的例子,需要的朋友可以参考下
  • C语言动态数组原理及实现

    万次阅读 多人点赞 2016-07-11 16:48:36
    近来编写几个程序,很多都用到了数组。但是对于数组的大小却是没有固定的,也就是说可以更改数组大小,其大小是可以变化的。并不像初学时的那样,告诉你一个范围,你就必须...C语言中不允许动态数组类型。例如: int n
  • C语言动态数组的逆序输出 #include "stdio.h" #include "stdlib.h" void nxsz(int *array,int n) { for(int i=n;i>=0;i--) printf("%10d",array[i]); } int main() { int N; printf("请输入数组长度%d\n"); ...
  • c语言动态数组二维数组2D arrays in C. Today I will discuss the usage of 2D arrays with pointers. This is one of the most complex topics of C programming, so I would like to suggest you to read this ...
  • C语言静态数组常常接触,因为静态数组简单好用,使用动态数组不如使用链表,动态数组处境尴尬。
  • #include<stdio.h> int main) { int a[6]={1,3,6,8,9},b,i,j; scanf%d&b; for(i=0;i;i++) if(b[i]) { for(j=5;j>=i;j--) a[j]=a[j-1]; a[i]=b; break; } else if(b>a[4]) a[5]=b;...i++) printf%2d,a
  • C语言动态数组实现

    2020-06-14 08:47:16
    环境:VS2015 头文件 DynamicArray.h #ifndef DYNAMICARRAY_H //如果没有定义 #define DYNAMICARRAY_H //则定义 #include <stdio.h> #include <... //动态数组地址 int capacity; //动态...
  • C语言动态数组建立方法

    千次阅读 2017-12-07 20:37:28
    动态数组是指在声明时没有确定数组大小的数组,即忽略圆括号中的下标;当要用它时,可随时用ReDim语句(C语言中用malloc语句)重新指出数组的大小。使用动态数组的优点是可以根据用户需要,有效利用存储空间。 ...

空空如也

空空如也

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

c语言动态数组

c语言 订阅