C 传递常数矩阵

关于这个问题，特别是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;
}

如果我消除

常量

，编译器将保持静止。我有什么误解吗？我想确保

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++中，如果将数组定义为包含所有矩阵行为的类，则不会有问题。

class Array {...};

我想，我没有很好地理解数组的概念以及C中数组的数组并将它们传递给函数。有什么启示吗

先谢谢你

EDIT2：与此同时，我仔细研究了这个问题，它似乎收敛到以下问题：C/C++隐式地将指向

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

s数组的指针转换为指向n

const int

s数组的指针。即使n

int

s的数组隐式转换为n

const int

s的数组。不支持隐式转换中的这种间接级别。以下内容将被拒绝（至少带有C中的警告）：

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

---

这是正确答案吗？

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

func( (void *)i ); func（（void*）i）；

---

如果可能的话，最好将i声明为const，但这种方法应该有效。

您的

i

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

当您将它传递给函数时，在函数内部，它将成为指向第一个元素的指针。编译器可以将

const

添加到指针或指向的对象：一个包含3个整数的数组。但是，它不能将指向的对象从一个包含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;
}

#包括
typedef const int数组_的_3_常数[3]；
无效函数（int（*const i）[3]）{
++i[0][0]；
printf（“值：%d\n”，i[1][1]）；
}
void gunc（数组中的常量*i）{
++i[0][0]；/*错误*/
printf（“值：%d\n”，i[1][1]）；
}
内部主（空）{
inti[3][3]={{0,1,2}，{3,4,5}，{6,7,8}；
func（i）；
func（_3_常数的数组*）i）；/*警告*/
gunc（一）；/*警告*/
gunc（_3_常数*的数组_）i）；
返回0；
}

铸造到

（void*）

很难看。。。为什么不直接转换为常量，如下所示：

func（（const int（*）[3]）i）#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;
}