Выражение размера параметра массива переменной длины с побочными эффектами

... можно опустить переменную размера и ... размер, который будет оцениваться во время выполнения, ...; но какая польза?

Информация о размере верхнего уровня потеряна ????, в аргументе массива теперь является параметр указателя. Однако с аргументами функции 2D VLA, которые превращаются в указатель на массив 1D, код знает об этом измерении массива.

void g(size_t size, size_t size2, int arr[size][size2]) {
  printf("g: %zu\n", sizeof(arr));
  printf("g: %zu\n", sizeof(arr[0]));
}

int main(void) {
  int arr[10][7];
  g(10, 7, arr);
}

Выход

g: 8   pointer size
g: 28  7 * int size

В качестве альтернативы можно передать указатель на массив.

void g2(size_t size, size_t size2, int (*arr)[size][size2]) {
  printf("g2: %zu\n", sizeof(arr));
  printf("g2: %zu\n", sizeof(*arr));
}

int main(void) {
  int arr[10][7];
  g2(10, 7, &arr);
}

Выход

g2: 8    pointer size
g2: 280  10 * 7 * int size

C 2018 6.9.1 обсуждает определения функций и сообщает нам в параграфе 10:

При входе в функцию вычисляются выражения размера каждого изменяемого параметра…

Согласно 6.7.6 3, изменяемый тип - это тип, который имеет тип массива переменной длины в своих деклараторах, возможно, вложенный. (Таким образом, int a[n] изменяется по-разному, поскольку это массив переменной длины, а int (*a[3])[n] фиксированной длины также изменяется по-разному, поскольку вложенный в него тип массива переменной длины.)

В случае void foo(int n, int a[][n]) мы видим, что n необходимо вычислить, потому что компилятору нужен размер для вычисления адресов для таких выражений, как a[i][j]. Однако для void foo(int n, int a[n]) такой необходимости нет, и мне не ясно, применяется ли приведенный выше текст к типу параметра до настройки (int a[n]) или после настройки (int *a).

Насколько я помню, когда я впервые обратил на это внимание несколько лет назад, я нашел как компилятор, который оценивал выражение, так и компилятор, который этого не делал, для прямого параметра массива. Вызов foo, который был определен с помощью void foo(int a[printf("Hello, world.\n")]) {}, выводит или не выводит строку в зависимости от компилятора. В настоящее время при компиляции с Apple LLVM 10.0.0 и clang-1000.11.45.5 в macOS 10.14.2 строка печатается. (Как упоминалось выше, для типа вложенного массива выражение должно быть вычислено, и все компиляторы, которые я пробовал, показали это. К сожалению, в настоящее время я не помню, какие это были компиляторы.)

Не ясно, что размер массива полезен для компилятора. Этот аспект стандарта C мог быть не полностью проработан. Есть особенность, которая добавляет некоторого смысла размеру; если размер объявлен с static:

void foo(int a[static SomeExpression]) { … }

тогда, согласно 6.7.6.3 7, a должен указывать как минимум на SomeExpression элементов. Это означает, что a не должен быть нулевым, что компилятор может использовать для оптимизации некоторых вещей. Однако у меня нет примеров того, как само число может помочь в оптимизации или других аспектах компиляции.

Я не вижу практического использования VLA в качестве параметра функции.

Только указатели на массивы имеют смысл, так как упрощают обход массивов и дают правильную информацию о размере.

int foo(int (*p)[2])
{

    printf("sizeof int = %zu\n", sizeof(int));
    printf("p + 0:%p\n", (void *)p);
    printf("p + 1:%p\n", (void *)(p + 1));
}

void g(size_t size, size_t size2, int (*arr)[size][size2]) 
{
  printf("g: %zu\n", sizeof(*arr));
  printf("g: %zu\n", sizeof(*arr[0]));
}


int main()
{
    foo(0);
    g(5,5,0);

    return 0;
}

sizeof int = 4                                                                                                                                                                                                                                              
p + 0:(nil)                                                                                                                                                                                                                                                 
p + 1:0x8                                                                                                                                                                                                                                                   
g: 100                                                                                                                                                                                                                                                      
g: 20