分配一个 3 维数组

Question

我必须使用 3 维数组，因为我想将图片分成正方形并将每个正方形的 RGB 平均值存储在我的数组中。 我想要这个尺寸，tab[height][width][3]， 所以我这样做了：

i = 0; j = 0; k = 0;

    float*** tab;
    tab = malloc((hauteur+1)*sizeof(float*));

    while(i <= hauteur){
        tab[i] = malloc((largeur+1)*sizeof(float**) );
        i++;
    }
    i = 0;
    while(i <= hauteur){
        j = 0;
        while (j <= largeur){
            tab[i][j] = malloc(3*sizeof(float***));
            j++;
        }
        i++;
    }

但我在 :tab[1][30][2]; 之后出现了段错误。

我的malloc 有问题吗？

这很奇怪，因为当我声明 tab 时它不会出现段错误： tab[hauteur][largeur][3].

（抱歉：“hauteur”在法语中的意思是“高度”，“largeur”的意思是“宽度”。）

（如果您认为需要检查我的整个函数：http://pastebin.com/eqQXz8Ad；它是 JPEG 文件的编写器。）

Answer 1

malloc 调用中的类型不正确。我建议如下：

tab = malloc( (hauteur + 1) * sizeof *tab );       // sizeof (float **)
tab[i] = malloc( (largeur + 1) * sizeof *tab[i] ); // sizeof (float *)
tab[i][j] = malloc( 3 * sizeof *tab[i][j] );       // sizeof (float)

鉴于tab的声明，以下都是正确的：

Expression                Type
----------                ----
       tab                float ***
      *tab                float **
    tab[i]                float **
   *tab[i]                float *
 tab[i][j]                float *
*tab[i][j]                float

我通常建议使用目标表达式的sizeof，而不是显式类型；这样，如果您更改了 tab 的类型（例如，从 float 更改为 double），您就不必接触 malloc 调用。

Answer 2

您正在制作的基本上是一个指向浮点数的数组的数组，而不是一个浮点数的三维数组。 你可能想看看这个Ambiguity in 2d array declaration in C。它用二维数组解决了类似的问题。

也许您的问题的解决方案可能如下所示：

float (*tab)[hauteur][largeur][3];    //declare a pointer to a real array

tab = malloc(hauteur * largeur * 3 * sizeof(float));    //Allocate room for threedimensional array

for (int i=0; i<hauteur; i++)
    for (int j=0; j<largeur; j++)
        for (int k=0; k<3; k++)
        {
            (*tab)[i][j][k] = (float)((i*100)+j*1000+k);    //Fill elements with something using threedimensional subscripting
        }
for (int i=0; i<hauteur; i++)
    for (int j=0; j<largeur; j++)
        for (int k=0; k<3; k++)
        {
            printf("[%d][%d][%d]=%f\n", i, j, k, (*tab)[i][j][k]);    //Check back data...
        }

已编辑 查看 cmets 我发现使用指向数组符号 (*array)[a][b]...[n] 的指针访问数组在某种程度上是“不自然的”，即使此符号在声明中明确报告了整个维度。为了使使用更友好，您可以使用以下允许众所周知的格式的表格：

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

int largeur = 10;
int hauteur = 10;

int main(int argc, char *argv[])
{
    float (*tab)[largeur][3];    //declare a bidimensional array of pointers to our variable
                               //this fools the compiler acting as a one more dimension array of variable

    tab = malloc(hauteur * largeur * 3 * sizeof(float));    //Allocate room for threedimensional array

    for (int i=0; i<hauteur; i++)
        for (int j=0; j<largeur; j++)
            for (int k=0; k<3; k++)
            {
                tab[i][j][k] = (float)((i*100)+j*1000+k);    //Fill elements with something using threedimensional subscripting
                //This use the natural addressing...
            }
    for (int i=0; i<hauteur; i++)
        for (int j=0; j<largeur; j++)
            for (int k=0; k<3; k++)
            {
                printf("[%d][%d][%d]=%f\n", i, j, k, tab[i][j][k]);    //Check back data...
            }
}

这种技巧之所以奏效，是因为C语言中缺少多维数组的概念。
C 只知道数组，或者更好的是它应该是 string 的东西，所以二维数组只是一些东西的数组的数组。如果我们再增加一个维度，它就是一个数组的数组，它是一个数组的数组……等等，我们每增加一个维度。
这定义了 C 中数组的内存布局以及编译器用来访问数据的寻址方法。因为数据在内存中流式传输以访问特定下标处的值，所以编译器需要计算除第一个维度之外的所有维度所使用的空间。

+++ 我修复了一个错误，现在该示例可以在任何符合 C99-C11 的编译器下编译并且可以正常工作。

Answer 3

如果您非常在意效率，您应该考虑使用单维数组（如Frankie_C's answer）：

 int height = something_to_compute_height();
 int width = something_to_compute_width();
 double *arr = malloc(height*width*3*sizeof(double));
 if (!arr) { perror("malloc"); exit(EXIT_FAILURE); }

^{（顺便说一句，即使我们都是以法语为母语的人，让我们在这里尝试在问题和代码中使用英语）}

那么你可以定义一个宏来简化arr中的某些元素

#define ELEM_ARR(a,i,j,k) a[i*width*height+j*width+k]
#define ARR(i,j,k) ELEM_ARR(arr)

^{（你有想法，细节可以不同）}

这可能比指向指针数组的指针数组更有效，因为 cache 局部性并且您只需要一次分配。

仔细选择row-major 或列主要访问权限以适应最频繁的访问模式。

如果height 和width 特定于每个数组，您可以在struct 中使用一些flexible array member 作为最后一个。

根据经验，只有当所有维度（可能最后一个维度除外）都是编译时常量时，才在 C 中使用多维数组很有用，例如double arr3d[3][4][5];;否则，最好有一个单维数组，自己做索引计算。

顺便说一句，如果您非常关心性能，您可能会担心OpenCL 和OpenMP（并且两者通常都更喜欢一维数组）。