ADT-Array

核心知识点：

多参数函数的使用

使用标准库<cstdarg>中重要的宏定义实现函数的参数可变

Status fun(Type ele, Type e, . . .)

{

va_list(ap);//首先声明va_list类型的变量

va_start(ap,e);//然后调用va_start传入两个参数，第一个是事先定义的va_list变量，第二个是函数参数里的一个形参变量、注意：第二个参数不能是引用类型

va_arg(ap, Type);//两个参数，返回Type类型的形参列表里e的下一个参数

va_end(ap); //结束时由va_list调用，形参不一定读完

}

存在不足：两个不确定的类型转换会出现不确定的情况等

参考：https://baike.baidu.com/item/stdarg/10282385?fr=aladdin

#include <iostream>
#include <cstdio>
#include <cstdarg>

using namespace std;

#define MAX_ARRAY_DIM 8//数组的最大维数为8

template<class T>
struct array_struct{
    T *base;
    int dim;//维数
    int *bounds;//数组维界基址
    int *constants;//用于计算偏移量
};

template<class T>
class Array
{
public:
    Array(){}
    Array(int dim, ...);//初始化，为base、bounds、constants数组申请空间
    ~Array() {  }
    void DestoryArray();
    void Locate(va_list ap, int &off);//辅佐函数，计算（i，j，k，，，）单元的偏移量off
    void ValueOf(T &e,int temp, ...);//得到（i，j，k，，，）的值
    void Assign(T e, ...);//赋值e到（i，j，k，，，）单元
    void Show();//二维打印
private:
    array_struct<T> A;
};

int main() {
    try {
        Array<int> Ab(3, 2, 2, 3);//2*2*3数组
        Ab.Assign(3, 0, 0, 0);
        Ab.Assign(7, 0, 0, 1);
        Ab.Assign(8, 0, 0, 2);
        Ab.Assign(1, 0, 1, 0);
        Ab.Assign(10, 0, 1, 1);
        Ab.Assign(-1, 0, 1, 2);

        Ab.Assign(3, 1, 0, 0);
        Ab.Assign(7, 1, 0, 1);
        Ab.Assign(8, 1, 0, 2);
        Ab.Assign(1, 1, 1, 0);
        Ab.Assign(10, 1, 1, 1);
        Ab.Assign(-1, 1, 1, 2);
        Ab.Show();

        //验证valueof
        int e = 0;
        Ab.ValueOf(e, 99, 0, 1, 2);//temp不起作用,va_start()参数不能包含引用类型
        cout << "ValueOf(0,1,2)=" << e << endl;

        //验证assign
        Ab.Assign(0, 0, 0, 0);
        Ab.Show();

        Ab.DestoryArray();
    }
    catch (const char *s)
    {
        cout << s;
    }
    system("pause");
}
template<class T>
void Array<T>::Show() 
{
    int elemtotal = 1;
    for (int i = 0, j = A.dim; i < j; i++)
        elemtotal *= A.bounds[i];
    cout << "数组的元素（按二维写出）：" << endl << endl;
    for (int i = 0; i < elemtotal; i++)
    {
        cout << *(A.base + i) << '	';
        if (!((i + 1) % A.constants[0]))
            cout << endl << endl;
    }
}

template<class T>
void Array<T>::Assign(T e, ...) {
    va_list(ap);
    va_start(ap, e);
    int off = -1;
    Locate(ap, off);
    *(A.base + off) = e;
    return;
}
template<class T>
void Array<T>::ValueOf(T &e, int temp, ...) {
    va_list(ap);
    va_start(ap, temp);
    int off = 2;
    Locate(ap, off);
    e = *(A.base + off);
    return;
}
template<class T>
void Array<T>::Locate(va_list ap, int &off) {
    off = 0;
    for (int i = 0; i < A.dim; i++)
    {
        int ind = va_arg(ap, T);
        if (ind < 0 || ind >= A.bounds[i])
        {
            throw"Locate():维数错误";
            return;
        }
        off += A.constants[i] * ind;
    }
}
template<class T>
Array<T>::Array(int dim, ...)
{
    if (dim<1 || dim>MAX_ARRAY_DIM)
    {
        throw"Array():维数非法";
        return;
    }
    //bounds数组用于记录dim个维度个长度
    A.dim = dim;
    try {
        A.bounds = new int[dim];//开辟dim大小的int数组
    }
    catch (const bad_alloc &) {
        throw"Array():空间开辟失败！";
        return;
    }

    //统计总共需要的T变量的空间的个数
    int elemtotal = 1;
    va_list(ap);
    va_start(ap, dim);
    for (int i = 0; i < dim; i++) {
        A.bounds[i] = va_arg(ap, int);
        if (A.bounds[i] <= 0) {
            throw"Array(): bounds[dim]初始化错误！";
            return;
        }
        elemtotal *= A.bounds[i];
    }
    va_end(ap);
    try {
        A.base = new T[elemtotal];//线性开辟总空间
    }
    catch (const bad_alloc &) {
        throw"Array():空间开辟失败！";
        return;
    }
    //初始化base
    for (int i = 0; i < elemtotal; i++)
        *(A.base + i) = 0;

    try {
        A.constants = new int[dim];//记录偏移量的int数组constants分配空间
    }
    catch (const bad_alloc &) {
        throw"Array():空间开辟失败！";
        return;
    }

    //计算并得到 偏移量数组constants
    A.constants[dim - 1] = 1;
    for (int i = dim - 2; i >= 0; i--) {
        A.constants[i] = A.constants[i + 1] * A.bounds[i + 1];
    }
    return;
}

template<class T>
void Array<T>::DestoryArray() {
    delete[]A.base;
    delete[]A.bounds;
    delete[]A.constants;
    return;
}