数组指针的常量正确性？

Question

有人提出，在现代 C 语言中，我们应该始终通过数组指针将数组传递给函数，因为数组指针具有强类型。示例：

void func (size_t n, int (*arr)[n]);
...

int array [3];
func(3, &array);

这听起来可能是防止各种类型相关和数组越界错误的好主意。但后来我突然想到我不知道如何将 const 正确性应用于此。

如果我这样做void func (size_t n, const int (*arr)[n])，那么它是正确的。但是由于指针类型不兼容，我无法再传递数组。 int (*)[3] 与 const int (*)[3]。限定符属于指向的数据，而不属于指针本身。

调用者中的显式转换会破坏增加类型安全的整个想法。

如何将 const 正确性应用于作为参数传递的数组指针？有可能吗？

---

编辑

就像信息一样，有人说像这样通过指针传递数组的想法可能起源于 MISRA C++:2008 5-2-12。参见例如PRQA's high integrity C++ standard。

Answer 1

除了演员表之外没有其他办法。这是以这种方式传递数组的想法的重大缺点。

Here is 一个类似的线程，将 C 规则与 C++ 规则进行比较。我们可以从这个比较中得出结论，C 规则设计得不是很好，因为您的用例是有效的，但 C 不允许隐式转换。另一个这样的例子是将T ** 转换为T const * const *；这是安全的，但 C 不允许。

请注意，由于n 不是常量表达式，因此int n, int (*arr)[n] 与int n, int *arr 相比没有任何额外的类型安全性。你仍然知道长度 (n)，并且它仍然是无声的未定义行为来越界访问，并且仍然是无声的未定义行为来传递一个实际上不是长度的数组n。

这种技术在传递非 VLA 数组的情况下更有价值，当你传递一个指向错误长度数组的指针时，编译器必须报告。

Answer 2

C 标准说（部分：§6.7.3/9）：

如果数组类型的规范包括任何类型限定符，则元素类型是这样限定的，不是数组类型。[...]

因此，在const int (*arr)[n] 的情况下，const 应用于数组的元素，而不是数组arr 本身。 arr 的类型是 pointer to array[n] of const int，而您正在传递 pointer to array[n] of int 类型的参数。两种类型都不兼容。

如何将 const 正确性应用于作为参数传递的数组指针？有可能吗？

这是不可能的。如果不使用显式强制转换，在标准 C 中就无法做到这一点。

但是，GCC 允许将其作为extension：

在 GNU C 中，指向带有限定符的数组的指针与指向其他限定类型的指针类似。例如，int (*)[5] 类型的值可用于初始化const int (*)[5] 类型的变量。 这些类型在 ISO C 中是不兼容的，因为 const 限定符正式附加到数组的元素类型而不是数组本身。

 extern void
 transpose (int N, int M, double out[M][N], const double in[N][M]);
 double x[3][2];
 double y[2][3];
 ...
 transpose(3, 2, y, x); 

---

延伸阅读：Pointer to array with const qualifier in C & C++

Answer 3

OP 描述了一个具有以下签名的函数func()。

void func(size_t n, const int (*arr)[n])

OP 想调用它传递各种数组

#define SZ(a) (sizeof(a)/sizeof(a[0]))

int array1[3];
func(SZ(array1), &array1);  // problem

const int array2[3] = {1, 2, 3};
func(SZ(array2), &array2);

如何将 const 正确性应用于作为参数传递的数组指针？

对于 C11，使用 _Generic 根据需要进行强制转换。 only 在输入是可接受的非const 类型时发生，从而保持类型安全。这是“如何”做到这一点。 OP 可能会认为它“臃肿”，因为它类似于this。这种方法将宏/函数调用简化为仅 1 个参数。

void func(size_t n, const int (*arr)[n]) {
  printf("sz:%zu (*arr)[0]:%d\n", n, (*arr)[0]);
}

#define funcCC(x) func(sizeof(*x)/sizeof((*x)[0]), \
  _Generic(x, \
  const int(*)[sizeof(*x)/sizeof((*x)[0])] : x, \
        int(*)[sizeof(*x)/sizeof((*x)[0])] : (const int(*)[sizeof(*x)/sizeof((*x)[0])])x \
  ))

int main(void) {
  #define SZ(a) (sizeof(a)/sizeof(a[0]))

  int array1[3];
  array1[0] = 42;
  // func(SZ(array1), &array1);

  const int array2[4] = {1, 2, 3, 4};
  func(SZ(array2), &array2);

  // Notice only 1 parameter to the macro/function call
  funcCC(&array1);  
  funcCC(&array2);

  return 0;
}

输出

sz:4 (*arr)[0]:1
sz:3 (*arr)[0]:42
sz:4 (*arr)[0]:1

代码也可以使用

#define funcCC2(x) func(sizeof(x)/sizeof((x)[0]), \
    _Generic(&x, \
    const int(*)[sizeof(x)/sizeof((x)[0])] : &x, \
          int(*)[sizeof(x)/sizeof((x)[0])] : (const int(*)[sizeof(x)/sizeof((x)[0])])&x \
    ))

funcCC2(array1);
funcCC2(array2);