用数组的基本操作实现对数组的初始化、赋值、返回数组的值以及定位操作

用数组的基本操作实现对数组的初始化、赋值、返回数组的值以及定位操作

实现：定义一个二维数组B，并将B初始化，然后将数组B的值依次赋值给数组A，并将数组A的元素输出。

目录结构：

CMakeList.txt:在add_executable中添加了SeqArray.h的头文件

头文件SeqArray.h

//
// Created by yuecaizheng on 2020/11/10.
//

#ifndef TEST_SEQARRAY_H
#define TEST_SEQARRAY_H

#endif //TEST_SEQARRAY_H


#include <stdlib.h>
#include "malloc.h"
#include "stdarg.h"     //标准头文件，包含va_start、va_arg、va_end 宏定义

#define MaxArraySezi 3

typedef int DateType;

typedef struct {
    DateType *base;     //数组元素的基地址
    int dim;        //数组的维数
    int *bounds;    //数组的每一维之间的界限地址
    int *constants;     //数组存储映像常量基地址
} Array;

int LocateArray(Array A, va_list ap, int *offset);

int InitArray(Array *A, int dim, ...)
//数组初始化
{
    int elemtotal = 1, i;  //elemtotal 是数组元素总数，初始值为1
    va_list ap;
    if (dim < 1 || dim > MaxArraySezi)     //如果维数不合法，返回0
        return 0;
    A->dim = dim;
    A->bounds = (int *) malloc(dim * sizeof(int));    //分配一个dim大小的内存单元
    if (!A->bounds)
        exit(-1);
    va_start(ap, dim);   //dim是一个固定参数，即可变参数的前一个参数
    for (int i = 0; i < dim; ++i) {
        A->bounds[i] = va_arg(ap, int);    //依次取得可变参数，即各维的长度
        if (A->bounds[i] < 0)
            return -1;
        elemtotal *= A->bounds[i];    //得到数组中元素总的个数

    }
    va_end(ap);
    A->base = (DateType *) malloc(elemtotal * sizeof(DateType));      //为数组分配所有元素分配内存空间
    if (!A->base)
        exit(-1);
    A->constants = (int *) malloc(dim * sizeof(int));     //为数组的常量基地址分配内存单元
    if (!A->constants)
        exit(-1);
    A->constants[dim - 1] = 1;
    for (int i = dim - 2; i >= 0; ++i) {
        A->constants[i] = A->bounds[i + 1] * A->constants[i + 1];
        return 1;
    }
    /*      再具体实现当中，使用了宏va_list、va_arg、va_start和va_end，这些宏定义都是在c语言中的头文件stdarg.h所包含
     * 首先定义一个指向可变参数的指针ap，然后调用va_start(ap,dim)使ap指向dim的下一参数，即第一个变长参数没然后调用
     * va_arg(ap,int)返回可变参数的值，最后使使用完毕va_end(ap)结束对可变参数的获取
     *      说明：在数组的初始化算法中，使用了变长参数表“...”传递参数。变长形式参数主要是用于参数不确定的情况，在上面的函数
     * 中,可能数组是两维空间，则需要两个参数传递给形式参数，也可能是三维数组，则需要将三个参数传递给形式参数。在函数的形式
     * 参数表中，变长形式参数表的前面至少要有一个固定参数。
     * */
}

void DestroyArray(Array *A) {
    //销毁数组
    if (A->base)
        free(A->base);
    if (A->bounds)
        free(A->bounds);
    if (A->constants)
        free(A->constants);
    A->base = A->bounds = A->constants = NULL;    //将各个指针指向空
    A->dim = 0;
}

int GetValue(DateType *e, Array A, ...)
//返回数组中指定的元素，将指定的数组中元素的小标赋值给e*
{
    va_list ap;
    int offset;
    va_start(ap, A);
    if (LocateArray(A, ap, &offset) == 0)    //找到元素所在数组中的相对位置
        return 0;
    va_end(ap);
    *e = *(A.base + offset);    //将元素赋值给e*
    return 1;
}

int SetValue(Array A, DateType e, ...)
//数组的赋值
{
    va_list ap;
    int offset;
    va_start(ap, e);
    if (LocateArray(A, ap, &offset) == 0)    //找到元素在数组中的相对位置
        return 0;
    va_end(ap);
    *(A.base + offset) = e;     //将e赋值给该元素
    return 1;
}

int LocateArray(Array A, va_list ap, int *offset) {
    //根据数组元素的下标，求出该元素在A中的相对地址offset
    {
        int i, instand;
        *offset = 0;
        for ( i = 0; i < A.dim; ++i) {
            instand = va_arg(ap, int);
            if (instand < 0 || instand >= A.bounds[i])
                return 0;
            *offset += A.constants[i] * instand;
        }
        return 1;
    }

}

main.cpp代码：

#include <stdio.h>
#include "malloc.h"
#include "stdlib.h"
#include "stdarg.h"

typedef int DateType;

#include "SeqArray.h"

int main() {
    Array A;
    DateType B[4][3] = {{12, 13, 14},
                        {22, 23, 24},
                        {33, 34, 35},
                        {45, 46, 47}};
    int dim = 2, bound1 = 4, bound2 = 3;    //初始化数组的维数和各维的长度
    DateType e;
    InitArray(&A, dim, bound1, bound2);    //构造一个4x3的二维数组A*
    printf("数组A的各维的长度为：");
    for (int i = 0; i < dim; i++) {         //输出数组A的各维的长度
        printf("%3d", A.bounds[i]);
        printf("\n%d行%d列的矩阵元素：\n", bound1, bound2);
        for (int i = 0; i < bound1; i++) {
            for (int j = 0; j < bound2; j++) {
                SetValue(A, B[i][j], i, j);    //将数组B中的元素赋值给A
                GetValue(&e, A, i, j);     //将数组A中的元素赋值给e*
                printf("A[%d][%d]=%3d\t", i, j, e);    //输出数组A中的元素

            }
            printf("\n");
        }
        printf("利用基地址输出元素:\n");
        for (int i = 0; i < bound1 * bound2; i++) {   //按照线性序列输出数组A中的元素
            printf("第%d个元素=%3d\t", i + 1, A.base[i]);
            if ((i + 1) % bound2 == 0)
                printf("\n");
        }
        DestroyArray(&A);
    }

}

运行结果：