C 函数 const 多维数组参数中的奇怪警告

Question

我收到一些关于此代码的奇怪警告：

typedef double mat4[4][4];

void mprod4(mat4 r, const mat4 a, const mat4 b)
{
/* yes, function is empty */
}

int main()
{
    mat4 mr, ma, mb;
    mprod4(mr, ma, mb);
}

gcc 输出如下：

$ gcc -o test test.c
test.c: In function 'main':
test.c:13: warning: passing argument 2 of 'mprod4' from incompatible pointer
type
test.c:4: note: expected 'const double (*)[4]' but argument is of type 'double
(*)[4]'
test.c:13: warning: passing argument 3 of 'mprod4' from incompatible pointer
type
test.c:4:
note: expected 'const double (*)[4]' but argument is of type 'double
(*)[4]'

如果我将函数定义为：

void mprod4(mat4 r, mat4 a, mat4 b)
{
}

或在 main 中定义矩阵为：

mat4 mr;
const mat4 ma;
const mat4 mb;

或在 main 中调用函数为：

mprod4(mr, (const double(*)[4])ma, (const double(*)[4])mb);

甚至定义 mat4 as：

typedef double mat4[16];

使警告消失。这里发生了什么？我是不是在做一些无效的事情？

gcc 版本是 4.4.3（如果相关）。

我还在 gcc bugzilla 上发布了： http://gcc.gnu.org/bugzilla /show_bug.cgi?id=47143

我当前的解决方法是制作丑陋的宏来为我投射东西：

#ifndef _NO_UGLY_MATRIX_MACROS

#define mprod4(r, a, b) mprod4(r, (const double(*)[4])a, (const double(*)[4])b)

#endif

---

Joseph S. Myers 在 gcc bugzilla 上的回答：

不是错误。函数参数 属于“指向 array[4] 的指针”类型 const double”因为 const 位于 数组类型适用于元素 递归地键入，然后 仅最外层数组类型 数组类型的参数衰减为 指针，传递的参数是 类型为“指向数组[4]的指针” double” 数组到指针衰减后， 唯一的情况是限定符是 允许添加到作业中， 参数传递等是限定符 立即指针目标，而不是 那些嵌套得更深。

对我来说听起来很混乱，就像函数所期望的那样：

pointer to array[4] of const doubles

我们正在传递

pointer to const array[4] of doubles

。

或者是相反的情况？警告表明该函数需要 a:

const double (*)[4]

在我看来更像是 a

pointer to const array[4] of doubles

我真的对这个答案感到困惑。有懂的人可以解释一下并举例说明吗？

Answer 1

我认为问题在于 C99 6.5.16.1(1) 中指定的约束，这些约束似乎禁止在赋值中混合限定，但包含限定符异常的指针除外被定义。问题在于，使用间接指针时，您最终会将指向一个事物的指针传递给指向另一个事物的指针。该赋值无效，因为如果有效，您可以使用以下代码欺骗它修改 const 限定对象：

const char **cpp;
char *p;
const char c = 'A';
cpp = &p;  // constraint violation
*cpp = &c; // valid
*p = 0;    // valid by itself, but would clobber c

cpp 看起来似乎很合理，它承诺不修改任何 char 可能会被分配一个指向指向非限定 char 的对象的指针。毕竟，这是允许单间接指针的，这就是为什么，例如，您可以将可变对象传递给 strcpy(3) 的第二个参数，将第一个参数传递给 strchr(3 )，以及使用 const 声明的许多其他参数。

但是对于间接指针，在下一个级别，允许从合格的指针进行赋值，现在完全不合格的指针赋值将破坏合格的对象。

我没有立即看出二维数组如何导致这种情况，但无论如何它都会遇到标准中的相同约束。

由于在您的情况下，您实际上并没有欺骗它破坏 const，因此您的代码的正确做法似乎是插入强制转换。

---

更新：好的，伙计们，这个问题发生在 C faq，整个讨论也进行了多次在 gcc 错误列表 和 gcc 邮件列表上。

• Gcc 错误列表：http://gcc.gnu.org/bugzilla/ show_bug.cgi?id=20230。
• C FAQ：问题 11.10：http://c-faq.com/ansi/constmismatch .html

教训：当需要 const T *x 时，您可以通过显式异常传递 T *x，但是 T *x 和 const T *x 仍然是不同的类型，因此您不能将指向其中之一的指针传递给指向另一个的指针。

Answer 2

解释一下 Joseph 所说的：该函数期望传入一个指向 const double 的 array[4] 的指针，但您传入的是一个指向 double 的 array[4] 的指针。这些类型不兼容，因此您会收到错误。它们看起来应该兼容，但事实并非如此。

为了将参数传递给函数（或变量赋值），您始终可以将 X 转换为 const X 或 指向 X 的指针 code> 指向任何类型 X 的 const X 指针。例如：

int x1 = 0;
const int x2 = x1;  // ok
int *x3 = &x1;
const int *x4 = x3;  // ok: convert "pointer to int" to "pointer to const int"
int **x5 = &x3;
const int **x6 = x5;  // ERROR: see DigitalRoss's answer
int *const *x7 = x5;  // ok: convert "pointer to (pointer to int)" to
                      //             "pointer to const (pointer to int)"

您只能向 添加限定符（即 const、volatile 和 restrict 限定符）第一层指针。您无法将它们添加到更高级别的指针，因为 DigitalRoss 提到，这样做会让你意外地违反常量正确性。这就是约瑟夫所说的“唯一的情况
允许在赋值、参数传递等中添加限定符
直接指针目标上的限定符，而不是嵌套得更深的限定符。”

因此，让我们回到 Joseph 的响应，您无法将指向 double 的 array[4] 的指针转换为指针到 const double 的 array[4] ，因为没有类型 X ，因此您可以从 指向 X 的指针 转换为 指向 const X 的指针

如果您尝试将 array[4] of double 用于 X，您会发现可以转换为 >指向 double 的 const array[4] 的指针，这是一种不同的类型，但是 C 中不存在这种类型：您可以拥有一个 const 类型的数组，但确实有。没有 const 数组这样的东西，

因此，没有办法完美解决您的问题，您必须向所有函数调用添加强制转换（手动或通过宏或辅助函数）。 ），重写您的函数以不采用 const 参数（不好，因为它不允许您传入 const 矩阵），或者更改 mat4类型为一维数组或结构体，如 用户502515建议。

Answer 3

为了实际解决这个问题，可以使用一个结构体，并将 double[4][4] 更改为有点尴尬的 double (*)[4]避免了这种情况，并且常量也直观地发挥作用——同时使用相同数量的内存：

struct mat4 {
        double m[4][4];
};

void myfunc(struct mat4 *r, const struct mat4 *a, const struct mat4 *b)
{
}

int main(void)
{
        struct mat4 mr, ma, mb;
        myfunc(&mr, &ma, &mb);
}

Answer 4

我认为在 C99 中，你可以这样做，但我不确定它会有帮助：

void mprod4(double mr[4][4], double ma[const 4][const 4], double mb[const 4][const 4])
{

}

我手边没有 C99 编译器，但我记得读过 C99 规范中有关 [] 对于数组作为参数。您还可以在其中放置static（例如ma[static 4]），但这当然意味着其他含义。

编辑

这是第 6.7.3.5 节第 7 段。

将参数声明为“类型数组”应调整为“指向类型的限定指针”，其中类型限定符（如果有）是在 [ 和 中指定的类型限定符] 数组类型推导。如果关键字 static 也出现在数组类型派生的 [ 和 ] 中，则对于该函数的每次调用，相应的实际参数应提供对数组第一个元素的访问，该数组的元素数量至少与大小表达式指定的元素数量相同。

Answer 5

这是一个问题（恕我直言）：函数签名中的 double[4][4] 。

您知道它是一个double[4][4]，但编译器在函数参数列表中看到double(*)[4]，值得注意的是，它没有数组大小限制。它将 4 x 4 对象的 2D 数组转换为指向 4 个对象的 1D 数组的指针，并且该指针可以有效索引，就像它是 4 个对象的数组一样。

我将通过指针传递所有 mat4 对象：

void mprod4(mat4 *r, const mat4 *a, const mat4 *b);
// and, if you don't want to hairy your syntax
#define mprod4(r, a, b) (mprod4)(&r, (const mat4 *)&a, (const mat4 *)&b)

这将（我相信）确保 const 正确性和数组大小正确性。它可能会使 mprod4 更难编写，并且仍然涉及一些毛茸茸的演员，但它（恕我直言）是值得的（特别是在上面的宏之后）：

void mprod4(mat4 *r, const mat4 *a, const mat4 *b)
{
    // all indexing of the matricies must be done after dereference
    for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++)
      {
        (*r)[i][j] = (*a)[i][j] * (*b)[i][j];
        // you could make it easier on yourself if you like:
        #define idx(a, i, j) ((*a)[i][j])
        idx(r, i, j) = idx(a, i, j) * idx(b, i, j)
      }
}

当你写它，但我认为它在类型上会更清晰。 （也许我对C++想太多了......）

Answer 6

编译器只是肛门。

您传递的参数本质上是非常量指针，并且该函数被声明为接受常量指针作为参数。事实上，这两者是不相容的。这不是一个真正的问题，因为只要您可以将第一种类型的值分配给第二种类型的变量，编译器仍然应该工作。因此是警告但不是错误。

编辑：看起来 gcc 不会抱怨其他 con-const 到 const 转换，例如在需要 const char* 的地方传递 char* 。在这种情况下，我倾向于同意 Bugzilla 的 Joseph Myers 是正确的。