在C语言中，实现多维数组有以下几种常见方法：
### 静态多维数组
可以直接定义并初始化多维数组，例如定义一个四维数组：
```c
#include <stdio.h>
int main() {
int arr[2][3][4][5] = {
{
{
{0, 1, 2, 3, 4},
{5, 6, 7, 8, 9},
{10, 11, 12, 13, 14},
{15, 16, 17, 18, 19}
},
{
{20, 21, 22, 23, 24},
{25, 26, 27, 28, 29},
{30, 31, 32, 33, 34},
{35, 36, 37, 38, 39}
},
{
{40, 41, 42, 43, 44},
{45, 46, 47, 48, 49},
{50, 51, 52, 53, 54},
{55, 56, 57, 58, 59}
}
},
{
{
{60, 61, 62, 63, 64},
{65, 66, 67, 68, 69},
{70, 71, 72, 73, 74},
{75, 76, 77, 78, 79}
},
{
{80, 81, 82, 83, 84},
{85, 86, 87, 88, 89},
{90, 91, 92, 93, 94},
{95, 96, 97, 98, 99}
},
{
{100, 101, 102, 103, 104},
{105, 106, 107, 108, 109},
{110, 111, 112, 113, 114},
{115, 116, 117, 118, 119}
}
}
};
printf("arr[0][0][0][1] = %d\n", arr[0][0][0][1]);
return 0;
}
```
这种方式在定义时就确定了数组的大小和初始值，适合数组大小固定的情况[^4]。
### 动态多维数组
#### 动态二维数组
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
int Rows = 2, Cols = 3;
// 指针法
double **mat2d2 = NULL;
mat2d2 = (double**)malloc(Rows * sizeof(double*));
for (int r = 0; r < Rows; r++) {
mat2d2[r] = (double*)malloc(Cols * sizeof(double));
memset(mat2d2[r], 0, Cols * sizeof(double));
}
// 使用完后释放内存
for (int r = 0; r < Rows; r++) {
free(mat2d2[r]);
}
free(mat2d2);
return 0;
}
```
通过`malloc`函数动态分配内存，适合在运行时确定数组大小的情况。这里是先分配一个指针数组，再为每个指针分配内存块来存储数据。同时，使用完后需要释放分配的内存，避免内存泄漏[^5]。
#### 动态三维及以上数组
以动态三维数组为例：
```c
#include <stdio.h>
#include <stdlib.h>
#define ARRAY_SIZE 5*32*32 // 定义了5桢，每桢是32x32的矩阵
int main() {
unsigned char (*frame)[32][32];
frame = (unsigned char (*)[32][32])malloc(ARRAY_SIZE);
if (frame == NULL) {
printf("Memory allocation failed\n");
return 1;
}
// 使用数组
frame[0][0][0] = 1;
// 释放内存
free(frame);
return 0;
}
```
使用`malloc`分配连续的内存块来存储三维数组的数据，使用完后同样需要释放内存[^2]。
### 多维数组的赋值函数实现
```c
#include <stdio.h>
#include <stdarg.h>
#define MAX_DIM 3
typedef int ElemType;
typedef struct {
ElemType *base;
int dim;
int *bounds;
int *constants;
} Array;
// 初始化数组
int InitArray(Array &A, int dim, ...) {
if (dim < 1 || dim > MAX_DIM) return 0;
A.dim = dim;
A.bounds = (int *)malloc(dim * sizeof(int));
if (!A.bounds) return 0;
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) return 0;
elemtotal *= A.bounds[i];
}
va_end(ap);
A.base = (ElemType *)malloc(elemtotal * sizeof(ElemType));
if (!A.base) return 0;
A.constants = (int *)malloc(dim * sizeof(int));
if (!A.constants) return 0;
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;
}
// 定位元素位置
int Locate(Array &A, va_list ap, int &off) {
off = 0;
for (int i = 0; i < A.dim; i++) {
int ind = va_arg(ap, int);
if (ind < 0 || ind >= A.bounds[i]) return 0;
off += A.constants[i] * ind;
}
return 1;
}
// 给数组赋值
int Assign(Array &A, ElemType e, ...) {
va_list ap;
va_start(ap, e);
int off, result;
if ((result = Locate(A, ap, off)) <= 0) return result;
*(A.base + off) = e;
va_end(ap);
return 1;
}
// 获取数组元素值
int Value(Array &A, ElemType &e, ...) {
va_list ap;
va_start(ap, e);
int off, result;
if ((result = Locate(A, ap, off)) <= 0) return result;
e = *(A.base + off);
va_end(ap);
return 1;
}
int main() {
Array A;
int e;
InitArray(A, 3, 5, 6, 7);
Assign(A, 100, 1, 2, 3);
Value(A, e, 1, 2, 3);
printf("\nA[1,2,3]=%d", e);
return 0;
}
```
通过定义结构体和相关函数，可以实现多维数组的初始化、赋值和取值操作，这种方式更灵活，可用于处理不同维度和大小的数组[^3]。
扫一扫
1553
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
