使用c++实现一个类层次来管理不同维数的整数数组 （一维数组intArray、矩阵Matrix、三维数组Array3D、四维数组SquareMatrix） 要求Matrix和array3D继承intArray, 而SquareMatrix继承Matrix.

以下是使用C语言实现的类层次结构，用于管理不同维度的整数数组：

#include <stdio.h>
#include <stdlib.h>

// 基类 intArray
typedef struct intArray {
    int *data;
    int size;
} intArray;

// 创建 intArray 对象
intArray *createIntArray(int size) {
    intArray *arr = (intArray *)malloc(sizeof(intArray));
    arr->data = (int *)malloc(sizeof(int) * size);
    arr->size = size;
    return arr;
}

// 释放 intArray 对象
void freeIntArray(intArray *arr) {
    free(arr->data);
    free(arr);
}

// 子类 Matrix
typedef struct Matrix {
    intArray *rows;
    int rowSize;
    int colSize;
} Matrix;

// 创建 Matrix 对象
Matrix *createMatrix(int rowSize, int colSize) {
    Matrix *mat = (Matrix *)malloc(sizeof(Matrix));
    mat->rows = (intArray *)malloc(sizeof(intArray) * rowSize);
    for (int i = 0; i < rowSize; i++) {
        mat->rows[i].data = (int *)malloc(sizeof(int) * colSize);
        mat->rows[i].size = colSize;
    }
    mat->rowSize = rowSize;
    mat->colSize = colSize;
    return mat;
}

// 释放 Matrix 对象
void freeMatrix(Matrix *mat) {
    for (int i = 0; i < mat->rowSize; i++) {
        free(mat->rows[i].data);
    }
    free(mat->rows);
    free(mat);
}

// 子类 Array3D
typedef struct Array3D {
    Matrix *mats;
    int matSize;
    int rowSize;
    int colSize;
} Array3D;

// 创建 Array3D 对象
Array3D *createArray3D(int matSize, int rowSize, int colSize) {
    Array3D *arr = (Array3D *)malloc(sizeof(Array3D));
    arr->mats = (Matrix *)malloc(sizeof(Matrix) * matSize);
    for (int i = 0; i < matSize; i++) {
        arr->mats[i].rows = (intArray *)malloc(sizeof(intArray) * rowSize);
        for (int j = 0; j < rowSize; j++) {
            arr->mats[i].rows[j].data = (int *)malloc(sizeof(int) * colSize);
            arr->mats[i].rows[j].size = colSize;
        }
        arr->mats[i].rowSize = rowSize;
        arr->mats[i].colSize = colSize;
    }
    arr->matSize = matSize;
    arr->rowSize = rowSize;
    arr->colSize = colSize;
    return arr;
}

// 释放 Array3D 对象
void freeArray3D(Array3D *arr) {
    for (int i = 0; i < arr->matSize; i++) {
        for (int j = 0; j < arr->rowSize; j++) {
            free(arr->mats[i].rows[j].data);
        }
        free(arr->mats[i].rows);
    }
    free(arr->mats);
    free(arr);
}

// 子类 SquareMatrix
typedef struct SquareMatrix {
    Matrix mat;
} SquareMatrix;

// 创建 SquareMatrix 对象
SquareMatrix *createSquareMatrix(int size) {
    SquareMatrix *mat = (SquareMatrix *)malloc(sizeof(SquareMatrix));
    mat->mat.rows = (intArray *)malloc(sizeof(intArray) * size);
    for (int i = 0; i < size; i++) {
        mat->mat.rows[i].data = (int *)malloc(sizeof(int) * size);
        mat->mat.rows[i].size = size;
    }
    mat->mat.rowSize = size;
    mat->mat.colSize = size;
    return mat;
}

// 释放 SquareMatrix 对象
void freeSquareMatrix(SquareMatrix *mat) {
    for (int i = 0; i < mat->mat.rowSize; i++) {
        free(mat->mat.rows[i].data);
    }
    free(mat->mat.rows);
    free(mat);
}

int main() {
    // 创建不同维度的整数数组对象并使用
    intArray *arr1 = createIntArray(5);
    arr1->data[0] = 1;
    arr1->data[1] = 2;
    arr1->data[2] = 3;
    arr1->data[3] = 4;
    arr1->data[4] = 5;
    printf("arr1[0] = %d\n", arr1->data[0]);
    freeIntArray(arr1);

    Matrix *mat = createMatrix(2, 3);
    mat->rows[0].data[0] = 1;
    mat->rows[0].data[1] = 2;
    mat->rows[0].data[2] = 3;
    mat->rows[1].data[0] = 4;
    mat->rows[1].data[1] = 5;
    mat->rows[1].data[2] = 6;
    printf("mat[0][2] = %d\n", mat->rows[0].data[2]);
    freeMatrix(mat);

    Array3D *arr3 = createArray3D(2, 3, 4);
    arr3->mats[0].rows[0].data[0] = 1;
    arr3->mats[0].rows[0].data[1] = 2;
    arr3->mats[0].rows[0].data[2] = 3;
    arr3->mats[0].rows[0].data[3] = 4;
    arr3->mats[0].rows[1].data[0] = 5;
    arr3->mats[0].rows[1].data[1] = 6;
    arr3->mats[0].rows[1].data[2] = 7;
    arr3->mats[0].rows[1].data[3] = 8;
    arr3->mats[0].rows[2].data[0] = 9;
    arr3->mats[0].rows[2].data[1] = 10;
    arr3->mats[0].rows[2].data[2] = 11;
    arr3->mats[0].rows[2].data[3] = 12;
    printf("arr3[0][1][2] = %d\n", arr3->mats[0].rows[1].data[2]);
    freeArray3D(arr3);

    SquareMatrix *sqMat = createSquareMatrix(3);
    sqMat->mat.rows[0].data[0] = 1;
    sqMat->mat.rows[0].data[1] = 2;
    sqMat->mat.rows[0].data[2] = 3;
    sqMat->mat.rows[1].data[0] = 4;
    sqMat->mat.rows[1].data[1] = 5;
    sqMat->mat.rows[1].data[2] = 6;
    sqMat->mat.rows[2].data[0] = 7;
    sqMat->mat.rows[2].data[1] = 8;
    sqMat->mat.rows[2].data[2] = 9;
    printf("sqMat[1][2] = %d\n", sqMat->mat.rows[1].data[2]);
    freeSquareMatrix(sqMat);

    return 0;
}

在上述代码中，基类`intArray`定义了一个整型数组`data`以及其大小`size`；子类`Matrix`继承了`intArray`，并且定义了一个二维整型数组`rows`、行数`rowSize`和列数`colSize`；子类`Array3D`也继承了`intArray`，并且包含了一组`Matrix`对象；子类`SquareMatrix`继承了`Matrix`，并且定义了一个`Matrix`对象。每个子类都包含了创建和释放对象的函数。

在`main()`函数中，我们创建了不同维度的整数数组对象，并分别使用了它们。