C（3D）中的锯齿阵列

我怎样才能做到以下几点

double layer1[][3] = {
    {0.1,0.1,0.8},
    {0.1,0.1,0.8},
    {0.1,0.1,0.8},
    {0.1,0.1,0.8}
};
double layer2[][5] = {
    {0.1,0.1,0.1,0.1,0.8}
};
double *upper[] = {layer1, layer2};

在尝试了不同的想法后，我读了以下内容；无济于事。

我理解（希望如此）

与我想要的类似，但不起作用，因为层不是指针数组。我故意使用C

---

我试图避免这样做（这是有效的）

---

根据交错数组的定义，Layer1和Layer2是指针数组。 没有理由这样做

double ** upper[] = {layer1, layer2}

不工作。如果没有，请发布错误消息

---

唯一的问题是数组会衰减为指针。如果这是一个问题，您需要使用C99并读入您已经提到的线程。

根据锯齿数组的定义，Layer1和Layer2是指针数组。

struct {
  size_t length;
  size_t stride;
  double *data;
} upper = {
  {
    sizeof(layer1) / sizeof(layer1[0]),
    sizeof(layer1[0]) / sizeof(layer1[0][0]),
    (double *)layer1,
  },
  {
    sizeof(layer2) / sizeof(layer2[0]),
    sizeof(layer2[0]) / sizeof(layer2[0][0]),
    (double *)layer2,
  },
};

int i, j, k;
for (i = 0; i < sizeof(upper) / sizeof(upper[0]); i++) {
  for (j = 0; j < upper[i].length; j++) {
    for (k = 0; i < upper[i].stride; k++)
      printf(" %d" + !k, upper[i].data[upper[i].stride * j + k]);
    printf("\n");
  }
  printf("\n");
}

没有理由这样做

double ** upper[] = {layer1, layer2}

不工作。如果没有，请发布错误消息

唯一的问题是数组会衰减为指针。如果这是一个问题，您需要使用C99并读入您已经提到的线程。

struct{
struct {
  size_t length;
  size_t stride;
  double *data;
} upper = {
  {
    sizeof(layer1) / sizeof(layer1[0]),
    sizeof(layer1[0]) / sizeof(layer1[0][0]),
    (double *)layer1,
  },
  {
    sizeof(layer2) / sizeof(layer2[0]),
    sizeof(layer2[0]) / sizeof(layer2[0][0]),
    (double *)layer2,
  },
};

int i, j, k;
for (i = 0; i < sizeof(upper) / sizeof(upper[0]); i++) {
  for (j = 0; j < upper[i].length; j++) {
    for (k = 0; i < upper[i].stride; k++)
      printf(" %d" + !k, upper[i].data[upper[i].stride * j + k]);
    printf("\n");
  }
  printf("\n");
}

尺寸与长度；
步幅大小；
双*数据；
}上限={
{
sizeof（第1层）/sizeof（第1层[0]），
sizeof（layer1[0]）/sizeof（layer1[0][0]），
（双*）第1层，
},
{
sizeof（第二层）/sizeof（第二层[0]），
sizeof（layer2[0]）/sizeof（layer2[0][0]），
（双*）第2层，
},
};
int i，j，k；
对于（i=0；i

您必须认识到，C语言中的多维数组只是将行主数组打包到线性存储器中。只有编译时的类型才能知道实际的维度：在运行时的数据中找不到它们。

struct{
尺寸与长度；
步幅大小；
双*数据；
}上限={
{
sizeof（第1层）/sizeof（第1层[0]），
sizeof（layer1[0]）/sizeof（layer1[0][0]），
（双*）第1层，
},
{
sizeof（第二层）/sizeof（第二层[0]），
sizeof（layer2[0]）/sizeof（layer2[0][0]），
（双*）第2层，
},
};
int i，j，k；
对于（i=0；i

---

您必须认识到，C语言中的多维数组只是将行主数组打包到线性存储器中。实际的维度只在编译时由类型知道：它们在运行时的数据中找不到。

在现代C语言中，有一个工具调用component literal，至少部分实现了您想要的功能：

double (*(layer1[])) = {
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8}
};
double (*(layer2[])) = {
    (double[]){0.1,0.1,0.1,0.1,0.8}
};
double (*(*(upper[]))) = {layer1, layer2};

我在类型中加入了

（）

，向您展示了类型的绑定规则。但是要注意，在这种类型的编程中，您必须始终自己记住数组边界

Edit:作为

（double[]）{0.0}

的构造称为复合文字，其效果与您在第二个版本中声明的临时数组相同。优点是您不必为它们发明命名约定，访问这些临时变量的唯一方法是通过更大的数组。也许最好将

const

放入所有这些中，这样您就不会意外地更改指针：

double (*const(layer1[])) = {
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8}
};
double (*const(layer2[])) = {
    (double[]){0.1,0.1,0.1,0.1,0.8}
};
double (*const(*const(upper[]))) = {layer1, layer2};

---

这仍然允许您更改内容（所有的

都是双倍的
），但不允许更改指针。如果您知道在整个程序中，
double
本身不会改变，请将
double
更改为
double const
。
在现代C语言中，有一个工具调用component literal，至少可以部分实现您想要的功能：

double (*(layer1[])) = {
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8}
};
double (*(layer2[])) = {
    (double[]){0.1,0.1,0.1,0.1,0.8}
};
double (*(*(upper[]))) = {layer1, layer2};

我在类型中加入了
（）
，向您展示了类型的绑定规则。但是要注意，在这种类型的编程中，您必须始终自己记住数组边界

Edit:作为
（double[]）{0.0}
的构造称为复合文字，其效果与您在第二个版本中声明的临时数组相同。优点是您不必为它们发明命名约定，访问这些临时变量的唯一方法是通过更大的数组。也许最好将
const
放入所有这些中，这样您就不会意外地更改指针：

double (*const(layer1[])) = {
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8},
  (double[]){0.1,0.1,0.8}
};
double (*const(layer2[])) = {
    (double[]){0.1,0.1,0.1,0.1,0.8}
};
double (*const(*const(upper[]))) = {layer1, layer2};

这仍然允许您更改内容（所有的
都是双倍的
），但不允许更改指针。如果您知道在整个程序中，
double
本身不会改变，请将
double
更改为
double const
。
您声称这是C，但您使用的是
cout
。习惯的原因，无关-修复您声称这是C，但您使用的是
cout
。习惯的原因，不相关-修复不，它们不是，数组layer1、layer2根据定义是数组的数组。（由于ephemient，下面显示的错误）不起作用
layer1
的类型为
double[4][3]
（它衰减为
double*[3]
，而不是
double**
），同样地，对于
layer2
，在C中，数组和指针之间几乎没有显式的区别（虽然有区别，但这里要解释它们还远），但我必须说我自己还没有测试过它，是时候启动lill’old编译器了：）我理解这一点，但这里没有明确的指针声明，因此您发布的内容将无法工作。就我的理解而言，Jens的帖子完美地表达了我的意思，请投票支持他：）不，它们不是，数组layer1，layer2是数组的定义数组。（由于ephemient，下面显示的错误）不起作用
layer1
具有类型
double[4][3]
（该类型衰减为
double*[3]
，而不是
double**
），同样，对于
layer2
，C中也有