C++作业:C语言实现动态数组

C语言实现动态数组

要求

实验内容：

• 1：使用C语言实现一个长度可扩充的数组（包含必要的数据结构及函数），使用C，不能直接使用vector等现成的数据结构。
• 2：要求能存放int类型的数据（并思考如果扩展成适应任意类型元素的代码）
• 3：所写程序需能通过测试程序

所实现的数组结构至少实现以下接口（操作）：

1. array_initial: 对数组结构进行初始化
2. array_capacity: 返回数组结构的容量
3. array_size: 返回数组结构包含的元素个数
4. array_recap: 重新对数组结构申请空间
5. array_at: 返回对应位置的元素(的引用)
6. array_append: 在数组结构后面加入一个元素
7. array_insert: 在数组结构给定的位置插入一个元素
8. array_copy: 复制一个数组结构到另一个数组结构
9. array_compare: 比较两个数组结构是否相同，这里的相同是指里面的元素相同
10. array_destroy: 销毁一个数组结构
    自己为了调试方便,加了一个显示数组的函数array_show()
    实验目的：
    1：熟悉相关的指针操作, 复习动态内存的相关操作.
    2：理解C程序如何实现数据类型和围绕数据类型上操作的集合
    3：为未来理解类实现的数组vector做准备
    输入
    注：由于这次作业不需要提交main()函数，因此输入部分不需要过多关注
    

代码如下

//C语言实现动态数组
/*
* by-keli
* 主要是复习C语言内存管理的函数malloc(),realloc(),free()
* 2020.12.11
* */
#include<iostream>
#include<assert.h>
#pragma warning(disable:4996)//防止安全类报错
typedef struct
{   //包含的元素个数
    int count;
    //容量
    int capacity;
    //储存数据
    int* array;
} CArray;

//对数组结构进行初始化
void array_initial(CArray& array)
{//函数引用了array
    array.array = NULL;
    array.capacity = 0;
    array.count = 0;
}

//返回数组结构的容量
inline int array_capacity(CArray& array)
{
    return array.capacity;
}
//返回数组结构包含的元素个数
inline int array_size(CArray& array)
{
    return array.count;
}

//重新对数组结构申请空间
void array_recap(CArray& array, int capacity)
{//对array申请数据空间,容量为capacity;
//这里用malloc函数,也就是C语言的方法申请
//申请容量不一定有数据,count不去改动
    if (array.capacity == 0)//新申请内存
    {
        array.array = (int*)malloc(sizeof(int) * capacity);
        array.capacity = capacity;
    }
    else//在原来的内存的基础上增加内存,使用增加内存的函数
    {
        array.array = (int*)realloc(array.array,sizeof(int) * capacity);
        array.capacity = capacity;
    }
}

//返回对应位置的元素(的引用)
inline int& array_at(CArray& array, int index)
{
    return array.array[index];
}

//在数组结构后面加入一个元素
void array_append(CArray& array, int element)
{
    if (array.capacity >= array.count + 1)//容量要大于等于现在的数量加一
    {
        array.array[array.count] = element;//最后元素的下一个位置插入元素
    }
    else if (array.count > array.capacity)//容量小于大小
    {
        printf("容量小于数量\n");
        assert(0);
    }
    else//容量少一个
    {//重新申请内存
        array_recap(array, array.capacity + 1);
        array.array[array.count] = element;
    }
    array.count++;
}

//在数组结构给定的位置插入一个元素
void array_insert(CArray& array, int index, int element)
{//给定位置加入一个元素,先把它后面的元素向后移动一个位置
    if (array.capacity < array.count + 1)
    {//容量不够时,重新申请内存空间
        array_recap(array, array.count + 1);   
    }
   
    int i;
    for (i = array.capacity - 1; i > index; i--)
    {
        array.array[i] = array.array[i - 1];
    }
    array.array[index] = element;
}

//复制一个数组结构到另一个数组结构
void array_copy(CArray& src, CArray& dst)
{//dst是destination的缩写，表目的
//src是source的缩写，表源
    array_recap(dst, src.capacity);//申请空间
    int i;
    for (i = 0; i < src.capacity; i++)
    {
        dst.array[i] = src.array[i];
    }
    dst.count = src.count;
}

bool array_compare(CArray& array1, CArray& array2)
{
    if (array1.count != array2.count)
        return false;
    int i;
    for (i = 0; i < array1.count; i++)
    {
        if (array1.array[i] != array2.array[i])
            return false;
    }
    return true;
}

void array_destroy(CArray& array)
{
    free(array.array);
    array.capacity = 0;
    array.count = 0;
}
//输出动态数组
void array_show(CArray& array)
{
    int i;
    printf("展示:");
    for (i = 0; i < array.count; i++)
        printf("%d\t", array.array[i]);
    printf("\n");
}

/*************************************************************************
*下面是一个给你们方便在本地端测试的main函数
*实际上，我们OJ的测试面函数并不是这样的
*所以如果你在你的本地端用这个main函数测试通过了，并不代表在OJ上能够通过
***********************************************************************/


int main(int argc, char *argv[])
{
    CArray array;
    array_initial(array);
    array_recap(array, 10);
    assert(array_capacity(array) == 10);    
    //
    for (int i = 0; i < 20; ++i)
    {
        array_append(array, i);
    }
    assert(array_size(array) == 20);
    for (int i = 0; i < array_size(array); ++i)
    {
        assert(array_at(array, i) == i);
    }    
    //
    CArray array2, array3;
    array_initial(array2);
    array_initial(array3);    
    array_copy(array, array2);
    assert(array_compare(array, array2) == true);    
    array_copy(array, array3);
    assert(array_compare(array, array3) == true);    
    //
    array_insert(array2, 2, 3);   
    assert(array_compare(array, array2) == false);
    //
    array_at(array3, 2) = 5;
    assert(array_compare(array, array3) == false);
    //
    array_show(array);
    array_show(array2);
    array_show(array3);
    /
    array_destroy(array);
    array_destroy(array2);
    array_destroy(array3);    
    return 0;
}

结果展示

总结

• 复习了malloc(),sizeof(),realloc(),free()等C语言内存管理函数
• 了解到了assert()的用法,其作用是如果它的条件返回错误，则终止程序执行
• 用assert()函数时需要包含头文件assert.h
• 用C语言实现了动态数组