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

    2021-06-07 17:42:25
    中文名C语言动态数组释义相对于静态数组而言根据随程序需要而重新指定大小定义声明时没有确定数组大小的数组C语言动态数组词目释义编辑动态数组,是相对于静态数组而言。静态数组的长度是预先定义好的,在整个程序中...

    动态数组是指在声明时没有确定数组大小的数组,即忽略方括号中的下标;当要用它时,可随时用ReDim语句(C语言中用malloc语句)重新指出数组的大小。

    中文名

    C语言动态数组

    释    义

    相对于静态数组而言根    据

    随程序需要而重新指定大小

    定    义

    声明时没有确定数组大小的数组

    C语言动态数组词目释义

    编辑

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

    C语言动态数组为什么要使用动态数组?

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

    C语言动态数组动态数组与静态数组的对比

    对于静态数组,其创建非常方便,使用完也无需释放,要引用也简单,但是创建后无法改变其大小是其致命弱点!

    对于动态数组,其创建麻烦,使用完必须由程序员自己释放,否则严重会引起内存泄露。但其使用非常灵活,能根据程序需要动态分配大小。

    如何构建动态数组

    C语言动态数组遵循原则

    申请的时候从外层往里层,逐层申请;

    释放的时候从里层往外层,逐层释放。

    C语言动态数组构建所需指针

    对于构建一维动态数组,需要一维指针;

    对于二维,则需要一维,二维指针;

    三维需要一,二,三维指针;

    依此类推。

    C语言动态数组构建所需函数

    函数原型返 回功能说明

    void *malloc(unsigned int size);成功:返回所开辟

    空间首地址  失败:返回空指针向系统申请

    size字节的

    堆空间

    void *calloc(unsigned int num,  unsigned int size);成功:返回所开辟

    空间首地址  失败:返回空指针按类型申请

    num个size字

    节的堆空间

    void free(void *p);无返回值释放p指向

    的堆空间

    void *realloc(void *p,unsigned int  size);成功:返回新开辟

    空间首地址  失败:返回空指针将p指向的

    堆空间变为

    size

    C语言动态数组说明:

    (1)规定为void *类型,这并不是说该函数调用后无返回值,而是返回一个结点的地址,该

    地址的类型为void(无类型或类型不确定),即一段存储区的首址,其具体类型无法确定,只有使

    用时根据各个域值数据再确定。可以用强制转换的方法将其转换为别的类型。例如:double

    *pd=NULL; pd=(double *)calloc(10,sizeof(double));  表示将向系统申请10个连续的

    double类型的存储空间,并用指针pd指向这个连续的空间的首地址。并且用(double)对calloc( )

    的返回类型进行转换,以便把double类型数据的地址赋值给指针pd。

    (2)使用sizeof的目的是用来计算一种类型的占有的字节数,以便适合不同的编译器。

    (3)由于动态分配不一定成功,为此要附加一段异常处理程序,不致程序运行停止,使用户

    不知所措。通常采用这样的异常处理程序段:

    if(p==NULL) /* 或者if(!p)*/ { printf("动态申请内存失败!\n"); exit(1); //异

    常退出 }

    (4)这四个函数头文件均包含在中。

    (5)分配的堆空间是没有名字的 只能通过返回的指针找到它。

    (6)绝不能对非动态分配存储块使用free。也不能对同一块内存区同时用free释放两次。

    如:free(p);free(p);

    (7)调用 free() 时, 传入指针指向的内存被释放, 但调用函数的指针值可能保持不变, 因

    为p是作为形参而传递给了函数。严格的讲, 被释放的指针值是无效的, 因为它已不再指向所申请

    的内存区。这时对它的任何使用便可能会可带来问题。

    对于用malloc分配的内存区间,如果原来没有被使用过,则其中的每一位可能都是0;反之,

    如果这部分内存空间曾经被分配、释放和重新分配,则其中可能遗留各种各样的数据。也就是说,

    使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常运行,但经过一段时间后(内

    存空间已被重新分配)可能会出现问题,因此在使用它之前必须先进行初始化(可用memset函数

    对其初始化为0),但调用calloc()函数分配到的空间在分配时就已经被初始化为0了。

    当你在calloc()函数和malloc()函数之间作选择时,你需考虑是否要初始化所分配的内存空

    间,从而来选择相应的函数。

    C语言动态数组具体构建方法

    以三维整型数组array[n1][n2][n3]为例。

    先遵循从外层到里层,逐层申请的原则:

    最外层指针是array,它是个三维指针,所指向的是array[],其为二维指针。所以给array

    申请内存应:

    array=(int***)calloc(n1,sizeof(int**));

    次层指针是array[],它是个二维指针,所指向的是array[][],其为一维指针。所以给array[]

    申请内存应:

    for(i=0;i

    {

    array[i]=(int**)calloc(n2,sizeof(int*));

    }

    最内层指针是array[][],它是个一维指针,所指向的是array[][][],其是个整型常量。所

    以给array[][]申请内存应:

    for(i=0;i

    {

    for(j=0;j

    {

    array[i][j]=(int*)calloc(n3,sizeof(int));

    }

    }

    当然,你可以把它们整合在一起为:

    int i,j,k;

    int n1,n2,n3;

    int ***array;

    scanf("%d%d%d",&n1,&n2,&n3);

    array=(int***)calloc(n1,sizeof(int**));

    for(i=0;i

    {

    array[i]=(int**)calloc(n2,sizeof(int*));

    for(j=0;j

    {

    array[i][j]=(int*)calloc(n3,sizeof(int));

    for(k=0;k

    {

    array[i][j][k]=i+j+k+1;

    }

    }

    }

    最后不要忘了释放这些内存,这要遵循释放的时候从里层往外层,逐层释放的原则。

    分析过程可参考上面的解答,这里不再赘述。只给出代码吧:

    for(i=0;i

    {

    for(j=0;j

    {

    free(array[i][j]);//释放第三维指针

    }

    }

    for(i=0;i

    {

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

    }

    free(array);//释放第一维指针

    其余维的如四维创建过程大同小异,这里不再赘述。

    C语言动态数组基础概念

    编辑

    C#集合、C#动态数组的概念之集合,什么是集合呢?集合就如同数组,用来存储和管理一组特定类型的数据对象,除了基本的数据处理功能,集合直接提供了各种数据结构及算法的实现,如队列、链表、排序等,可以让你轻易地完成复杂的数据操作。在使用数组和集合时要先加入system.collections命名空间,它提供了支持各种类型集合的接口及类。集合本身上也是一种类型,基本上可以将其作为用来存储一组数据对象的容器,由于c#面向对象的特性,管理数据对象的集合同样被实现成为对象,而存储在集合中的数据对象则被称为集合元素。这里提到了接口这个概念,它也是面向对象编程进化的重要标准,我们在这里不做过多的讲解,先注重学习集合中的对象及其使用就可以了,下面我们来学习第一种集合:

    C#集合、C#动态数组的概念之C#动态数组ArrayList.ArrayList 类提供了继承了IList接口。什么是继承呢?这也是面向对象语言的重要特点之一,你们先把它理解为,如果一个对象继承了类或接口,那么它也具有了这个类和接口中的方法、属性,可以用这些继承的方法和属性来做相应的操作,比如:数组增加元素没有Add()方法,但是动态数组ArrayList继承了一个增加元素有Add()方法的接口,那么当它要增加元素的时候,不仅可以用索引,也可以用继承下来的Add()方法了。随着学习的深入,我会给大家再具体讲解继承的概念和使用继承的好处。那么下面让我们来看看动态数组所继承的这个接口IList它有什么特性呢?

    C#动态数组之 Ilist接口:定义了利用索引访问集合对象的方法,还继承了ICollection和IEnumerable接口,除实现了接口原有的方法成员外,其本身也定义多个专门的方法成员,例如新增、移除、在指定位置插入元素或是返回特定元素在集合中所在的位置索引,这些方法主要为集合对象提供类似数组的元素访问功能。

    C#动态数组之ILsit接口成员:add、insert、RemoveAt、Remove、contains、Clear、indexof方法,它最大的特色在于提供类似数组索引的访问机制。

    C#集合、C#动态数组的概念的基本情况就向你介绍到这里,希望对你了解和学习C#集合、C#动态数组的概念有所帮助。

    C语言动态数组必看知识

    编辑

    由于百科里贴的代码每行前都会有许多中文空格,造成直接复制粘贴到编译器上编译时会出现许多错误。(除非自己手工把代码前的空格全删掉)

    所以我特地把代码贴到了扩展资料那,要的话去那拿吧。

    C语言动态数组构建实例

    编辑

    C语言动态数组一维

    #include

    #include

    int main()

    {

    int n1,i;

    int *array;

    puts("输入一维长度:");

    scanf("%d",&n1);

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

    for(i=0;i

    {

    array[i]=i+1;

    printf("%d\t",array[i]);

    }

    free(array);//释放第一维指针

    return 0;

    }

    C语言动态数组二维

    #include

    #include

    int main()

    {

    int n1,n2;

    int **array,i,j;

    puts("输入一维长度:");

    scanf("%d",&n1);

    puts("输入二维长度:");

    scanf("%d",&n2);

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

    for(i=0;i

    {

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

    for(j=0;j

    {

    array[i][j]=i+j+1;

    printf("%d\t",array[i][j]);

    }

    puts("");

    }

    for(i=0;i

    {

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

    }

    free(array);//释放第一维指针

    return 0;

    }

    C语言动态数组三维

    #include

    #include

    int main()

    {

    int n1,n2,n3;

    int ***array;

    int i,j,k;

    puts("输入一维长度:");

    scanf("%d",&n1);

    puts("输入二维长度:");

    scanf("%d",&n2);

    puts("输入三维长度:");

    scanf("%d",&n3);

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

    for(i=0; i

    {

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

    for(j=0;j

    {

    array[i][j]=(int*)malloc(n3*sizeof(int)); //第三维

    for(k=0;k

    {

    array[i][j][k]=i+j+k+1;

    printf("%d\t",array[i][j][k]);

    }

    puts("");

    }

    puts("");

    }

    for(i=0;i

    {

    for(j=0;j

    {

    free(array[i][j]);//释放第三维指针

    }

    }

    for(i=0;i

    {

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

    }

    free(array);//释放第一维指针

    return 0;

    }

    C语言动态数组四维

    #include

    #include

    int main()

    {

    int n1,n2,n3,n4;

    int ****array;

    int i,j,k,m;

    puts("输入一维长度:");

    scanf("%d",&n1);

    puts("输入二维长度:");

    scanf("%d",&n2);

    puts("输入三维长度:");

    scanf("%d",&n3);

    puts("输入四维长度:");

    scanf("%d",&n4);

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

    for(i=0; i

    {

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

    for(j=0;j

    {

    array[i][j]=(int**)malloc(n3*sizeof(int*)); //第三维

    for(k=0;k

    {

    array[i][j][k]=(int*)malloc(n4*sizeof(int));//第四维

    for(m=0;m

    {

    array[i][j][k][m]=i+j+k+m+1;

    printf("%d\t",array[i][j][k][m]);

    }

    puts("");

    }

    puts("");

    }

    puts("");

    }

    for(i=0;i

    {

    for(j=0;j

    {

    for(k=0;k

    free(array[i][j][k]);//释放第四维指针

    }

    }

    for(i=0;i

    {

    for(j=0;j

    {

    free(array[i][j]);//释放第三维指针

    }

    }

    for(i=0;i

    {

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

    }

    free(array);//释放第一维指针

    return 0;

    }

    C语言动态数组数组案例

    编辑

    #include

    #include

    int main()

    {

    int*n,*p;

    int i;

    n=(int*)calloc(1,sizeof(int));

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

    {

    n[i]=i+1;

    printf("%d\t",n[i]);

    p=(int*)realloc(n,(i+2)*sizeof(int));//动态扩充数组

    if(p!=NULL)

    n=p;

    else

    {

    puts("error!");

    return 0;

    }

    }

    free(n);

    return 0;

    }

    C语言动态数组游戏应用

    编辑

    C语言动态数组预备知识

    (1)getch()

    函数原型: int getch(void);

    函数功能: 从控制台读取一个字符,但不显示在屏幕上。

    函数返回: 读取的字符。

    (2)rand()

    函数原型: int rand(void);

    函数功能: 随机函数, 产生0到32767间的随机整数(0到0x7fff之间)。

    函数返回: 随机整数

    所属文件:

    (3)srand()

    函数原型: void srand(unsigned seed);

    函数功能: 该函数和rand随机函数配合使用,产生随机数的起始发生数据。

    参数说明: seed为无符号整数。

    所属文件:

    (4)time()

    函数原型: time_t time(time_t *timer)

    函数功能: 得到机器的日历时间或者设置日历时间。

    函数返回: 机器日历时间。

    参数说明: timer=NULL时得到机器日历时间,timer=时间数值时,用于设置日历时间,

    time_t是一个long类型。

    所属文件:

    (5)'\b'实现退格,即当前光标后退一格。

    (6)'\a'实现响铃,即执行时计算机会嘟一声。

    (7)得到随机数值范围在a~b(包含b)的方法:rand()%(b-a+1)+a;

    C语言动态数组代码

    #include

    #include //getch()函数所需头文件

    #include //随机函数所需头文件

    #include //time()函数所需头文件

    void clear(void)//此函数用以清除当前行

    {

    printf("\r \r");

    }

    void start(void)

    {

    puts("这是消单词游戏的精简版,还不会图像编程的人可以看一看");

    puts(" 由于没有引入数据库,所以此单词是模拟的。");

    puts("按任意键开始,按Esc键结束,按tab键重新开始:");

    puts(" 一旦输错,将发出声音警告,你必须重新输入。");

    puts(" 按任意键开始,按Esc键结束:");

    if( '\x1b' == getch() ) //按Esc键结束

    {

    exit( 1 );

    }

    }

    int main()

    {

    char*c_rand,*c_input;

    int i,j,N,n,space,N_rand;

    start();

    printf("\r你想消最多由多少个字母组成的单词?(输入数字(1-9)");

    n=getch();

    N=n-'0';//将输入的字符转换为整型数字

    clear();//清除当前行

    if(!((N>=1&&N<=9)||n==27))//27是键Esc的ASII值

    {

    printf("\r范围错误,请重新开始:");

    getch();

    exit(1);//异常退出

    }

    if(n==27)

    return 0;

    srand(time(NULL));//用来对随机函数初始化

    c_rand=(char*)malloc(N+1);

    c_input=(char*)malloc(N+1);

    while(1)

    {

    N_rand=rand()%N+1;//实现单词长度随机定义

    for(i=0;i

    {

    c_rand[i]=(rand() ==0)?(rand()&+'A'):(rand()&+'a');//随机取个字母

    }

    c_rand[N_rand]='\0';

    //下面四行代码实现单词位置随机出现

    space=rand() % 50;

    putchar('\r');

    for(i=0;i

    putchar(' ');

    printf("%s",c_rand);

    for(i=0;i

    {

    c_input[i]=getch();//用户输入

    if(c_input[i]=='\x1b')//"\x1b"代表的是Esc键

    break;

    //下面五行代码实现字母消失效果

    putchar('\r');

    for(j=0;j

    putchar(' ');

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

    putchar(' ');

    if(c_input[i]!=c_rand[i])

    {

    i=-1;

    putchar('\a');

    //下面四行代码代码字母重现效果

    putchar('\r');

    for(j=0;j

    putchar(' ');

    printf("%s",c_rand);

    }

    }

    if(c_input[i]=='\x1b')//"\x1b"代表的是Esc键

    break;

    }

    free(c_rand);

    free(c_input);

    return 0;

    }

    词条图册

    更多图册

    展开全文
  • C语言动态数组从键盘读入n个整数,使用动态数组存储所读入的整数,并计算它们的和与平均值分别输出。要求尽可能使用函数实现程序代码。平均值为小数的只保留其整数部分。样例输入:53 4 0 0 2样例输出:9 1样例输入:73...

    C语言动态数组

    从键盘读入n个整数,使用动态数组存储所读入的整数,并计算它们的和与平均值分别输出。要求尽可能使用函数实现程序代码。平均值为小数的只保留其整数部分。

    样例输入:

    5

    3 4 0 0 2

    样例输出:

    9  1

    样例输入:

    7

    3 2 7 5 2 9 1

    样例输出:

    29  4

    代码如下:

    #include

    int addAll(int a[],int N);

    int aveFun(int sum,int n);

    int main(){

    int N;

    int sum=0,ave=0;

    scanf("%d",&N);

    int a[N];

    for(int i=0;i

    scanf("%d",&a[i]);

    }

    sum = addAll(a,N);

    ave = aveFun(sum,N);

    printf("%d %d",sum,ave);

    }

    int addAll(int a[],int N){

    int sum=0;

    for(int i=0;i

    sum += a[i];

    }

    return sum;

    }

    int aveFun(int sum,int N){

    return sum/N;

    }

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • 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语言静态数组常常接触,因为静态数组简单好用,使用动态数组不如使用链表,动态数组处境尴尬。静态数组:int a[32]={0}动态数组:可以动态增加空间,但静态数组不能。动态数组结构体。struct dynamicArray{void** ...

    C语言静态数组常常接触,因为静态数组简单好用,使用动态数组不如使用链表,动态数组处境尴尬。

    静态数组:

    int a[32]={0}

    动态数组:可以动态增加空间,但静态数组不能。

    动态数组结构体。

    struct dynamicArray

    {

    void** addr;

    //在堆区开辟数组

    int capacity;

    //数组容量

    int Size;

    //数组大小(指的是数组中元素的个数)

    };

    初始动态数组的容量。

    struct dynamicArray* initArray(int Capacity) {

    if (Capacity <= 0) {

    return;

    }

    struct dynamicArray* arr = malloc(sizeof(struct dynamicArray));

    //申请结构体指针

    if (arr)

    {

    //arr不为空

    arr->capacity = Capacity;

    arr->Size = 0;

    arr->addr = malloc(sizeof(void*) * Capacity);

    }

    else

    {

    printf("fail\n");

    return;

    }

    return arr;

    }

    向动态数组中插入数据。

    //插入数据(data)向数组(arr)中的某一个位置(pos)

    void insertArray(struct dynamicArray* arr, int pos, void* data) {

    if (arr) {

    if (pos<0 || pos>arr->Size)

    {

    //无效位置,强制尾插

    pos = arr->Size;

    }

    }

    if (data == NULL)

    {

    }

    if (arr) {

    if (arr->capacity == arr->Size)

    {

    //如果满空间,申请新空间

    int newCapacity = arr->capacity * 2;

    void** newSpace = malloc(sizeof(void*) * newCapacity);

    //把原空间,拷贝新空间

    if (newSpace)

    {

    memcpy(newSpace, arr->addr, sizeof(void*) * arr->capacity);

    //释放原空间

    free(arr->addr);

    //指向新空间

    arr->addr = newSpace;

    arr->capacity = newCapacity;

    //更新容量

    }

    }

    //插入数据到指定位置

    for (int i = arr->Size - 1; i >= pos; i--)

    {

    arr->addr[i + 1] = arr->addr[i];

    }

    arr->addr[pos] = data;

    arr->Size++;//更新大小

    }

    }

    完整代码:

    链接:https://pan.baidu.com/s/1D-KYLNDsr9D4vWdVF5u-ww

    提取码:kr6w

    展开全文
  • C语言构建动态数组完整实例本文以一个完整的实例代码简述了C语言构建动态数组的方法,供大家参考,完整实例如下:#include #include int main(void) {int len;int * arr;printf("请输入数组长度:");scanf("%d", &...
  • C语言实现动态数组

    2021-05-18 13:41:32
    前言在纯C语言编程中,数组的创建必须是固定的大小,因为C语言本身没有提供动态数组这种数据结构,这是一个让习惯了使用高级语言编程的人转做C开发面临的一个很头疼的问题,本篇文章就将介绍如何使用纯C语言编程实现...
  • c语言实现动态数组

    2021-09-01 22:43:30
    动态数组是一种比较常用的集合类,其相对于普通数组的优势是可以自动增容,相对于链表的优势是可以下标访问。 首先设计接口: 1、数据结构如下: #include<stdint.h> /// <summary> /// 数组对象 //...
  • c+中的动态数组使用

    2021-05-18 13:41:23
    C++的new操作符是该语言一个非常好的语法特性,然而实际使用中却发现new操作符有不少限制,为突出的一点便是用new操作符分配多维数组空间时,不能让数组的每一维都动态可变。本文将对此提出一个简单直观的解决方案,...
  • C语言动态创建数组并增加数组长度 #include <iostream> #include<stdlib.h> using namespace std; #define InitSize 10 typedef struct{ int *data; int MaxSize; int length; }Customer; void ...
  • C语言动态数组的实现在大型程序设计中,当程序中间数据量大需(本文共3页)阅读全文>>在许多程序设计中都要用到多维数组,如果数组每一维的大小都已知,则在变量说明中定义即可,否则,通常的方...(本文共2页)阅读...
  • C语言动态数组

    2021-05-20 18:43:09
    很多人在编写C语言代码的时候很少使用动态数组,不管什么情况下通通使用静态数组的方法来解决,在当初学习C语言的时候我就是一个典型的例子,但是现在发现这是一个相当不好的习惯,甚至可能导致编写的程序出现一些...
  • 提出问题请问在c语言里如何实现动态大小的数组啊,比如说int a[N];,这里N的值可以在程序中定,或者有什么方法可以实现类似的功能?总之只要在编译时不用制定数组大小就行。分析问题嵌入式系...
  • 查余补漏:在前几次的讲解中,有朋友提出C语言的内存分配只是malloc和free,然后还有在缓存章节的有朋友提出的内存四区,所以我在说数组之前,先进行补漏。我们前面在说内存分配的时候,并没有明确的说明内存四区的...
  • 另外,Redis中的sds就是一个经典的动态数组wengle|园豆:567(小虾三级)|2020-03-10 09:12你这种写法我倒是理解了,但是感觉存在一些问题,1,我们还是需要给结构体中的capacity赋一个初值,这个值又应该赋值为多少了...
  • C语言中的动态数组

    2021-03-14 09:47:31
    什么是动态数组 这里先引入一段对动态数组的说法 动态数组是相对于静态数组而言,从“动”字我们也可以看出它的灵活性,静态数组的长度是预先定义好的,在整个程序中,一旦给定大小后就无法改变。而动态数组则不然...
  • , 92年第2期C语言多维动态数组的实现唐李民(‘又湖北省进出口商品检验局科技处派橄 )摘本文利用^ o vid、要定义的内存管理函数、N SI C间进行的它由C语言提供的一 4且内存管理函数来完成在程序执行期间可以修改动态...
  • C语言动态分配数组(一维)当初学Pascal的时候就想过这个问题:如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用...
  • #include #include int main(){int **a;...//为二维数组分配3行for (i = 0; i < 3; ++i){//为每列分配4个大小空间a[i] = (int*)malloc(sizeof(int)*4);}//初始化for (i = 0; i < 3; ++i){f...
  • 静态数组在定义数组时,必须给出数组大小,不能使用变量,这点和动态数组不同. 下面代码是无法运行的,在编译期间就会报错 int i; cin>>i; int a[i]; 动态数组 动态数组是malloc或者new出来的,位于内存的堆区...
  • 动态数组的初始化实现 #include <iostream> using namespace std; struct dynamicArray{ void **pAddr; int m_capacity; int m_size; } struct dynamicArray *initdynamicArray(int capacity){ if...
  • c语言动态结构体数组

    千次阅读 2021-01-05 22:04:26
    学生信息管理系统中可以用到结构体数组进行数据的输入输出 typedef struct student//定义结构体 { char stu_number[20];... //创建动态结构体数组 stus=(Student*)malloc(sizeof(Student)*N); 结构体数组的使用
  • 这次的任务是将两个txt文件中的矩阵排列的数组读到两个分别的动态数组中,然后将两个矩阵相乘并且将结果存到第三个动态数组中。之所以要记录这次是因为想要把自己遇到的困难和学到的一些函数等记录下来,慢慢积累。...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼动态数组实现重载运算符求和#include#includeusing namespace std;class matrix{public:matrix(){x=0;y=0;}~matrix(){for(int i=0;idelete []p[i];p=NULL;}matrix(int xx...
  • #include #include int main(){int*n,*head;int i,j,temp;int k=0;//记录当前数组长度int MAX=...//创建动态数组head=n;//记录不用增加动态数组长度时的头指针cin>>i;//输入数组元素的值while(i!=0&&k...
  • C语言中如何实现动态数组:​方法一:int n;......int array[n];方法二:int n;......int *p;p=(int*)malloc(n*sizeof(int));int *p1;p1=(int*)calloc(n,sizeof(int));​二维数组:int (*p2)[6];//在c99之前...
  • C语言中,数组长度必须在创建数组时指定,并且...动态数组是相对于静态数组而言。静态数组的长度是预先定义好的,在整个程序中,一旦给定大小后就无法改变。而动态数组则不然,它可以随程序需要而重新指定大小。动态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 477,468
精华内容 190,987
关键字:

c动态数组