传递常量矩阵

Question

参考这个 问题，尤其是已接受的 litb 的回答，我想知道为什么 gcc 会抱怨这一点：

void func(const int (*ip)[3]) {
    printf("Value: %d\n", ip[1][1]);
}

int main() {
    int i[3][3] = { {0, 1, 2} , {3, 4, 5}, {6, 7, 8} };
    func(i);
    return 0;
}

如果我消除 const 编译器将保持静止。我是不是误会了什么？我想确保 func 不会修改我的数组。

编辑：如果我为矩阵定义数据类型，也会发生同样的事情：

typedef int Array[3][3];

void func(const Array *p) {
    printf("Value: %d\n", (*p)[1][1]);
}

int main() {
    Array a = { {0, 1, 2}, {3, 4, 5}, {6, 7, 8} };
    func(&a);
    return 0;
}

我接受，这种代码不是很 C 风格，更像是 C++。在 C++ 中，如果我将 Array 定义为包含所有矩阵行为的类，确实不会有问题。

class Array {...};

我想，我不太了解 C 中数组和数组数组的概念以及将它们传递给函数。有什么启示吗？

先感谢您。

EDIT2：同时，我对这个问题进行了一些思考，它似乎收敛到以下问题：C/C++ 隐式地将指向 int 的指针转换为指向 int 的指针代码>const int。因此，以下内容有效：

func(const int a[]) // aquivalent: func(const int *a)
{ ... }

int main() 
{
    int b[10];
    func(b);
    return 0;
}

但 C/C++ 不会将指向 n 个 int 数组的指针隐式转换为指向 n 个 const int 数组的指针。即使包含 n 个 int 的数组会隐式转换为包含 n 个 const int 的数组。不支持隐式转换中的这种间接级别。以下内容将被拒绝（至少在 C 中会出现警告）：

func(const int a[][n]) // aquivalent: func(const int (*a)[n])
{ ... }

int main()
{
    int b[m][n];
    func(b);
    return  0;
}

这类似于 C++ 不会将类型 A 的模板隐式转换为类型 B 的模板，即使 A 可以隐式转换为 B 的问题。两个模板的类型完全不同。

这是正确的答案吗？

Answer 1

您的 i 变量是一个包含 3 个元素的数组。

当您将它传递给函数时，在函数内部，它变成指向第一个元素的指针。编译器可以将 const 添加到指针或指向的内容：3 个 int 的数组。然而，它不能将指向的内容从3 个整数的数组更改为3 个常量的数组。

我认为你需要自己做演员。

#include <stdio.h>

typedef const int array_of_3_constants[3];

void func(int (* const i)[3]) {
  ++i[0][0];
  printf("Value: %d\n", i[1][1]);
}

void gunc(array_of_3_constants *i) {
  ++i[0][0];                              /* error */
  printf("Value: %d\n", i[1][1]);
}

int main(void) {
  int i[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
  func(i);
  func((array_of_3_constants*)i);         /* warning */
  gunc(i);                                /* warning */
  gunc((array_of_3_constants*)i);
  return 0;
}

Answer 2

您不需要消除 const，只需通过将调用中的参数强制转换为 func 来传递兼容的值：

   func( (void *)i );

如果可能，最好将 i 声明为 const，但此 hack 应该有效。