То, что вы говорите в своем посте, абсолютно правильно. Я бы сказал, что каждый разработчик C приходит к точному тому же открытию и к точно такому же выводу, когда (если) они достигают определенного уровня владения языком C.

Когда специфика вашей области приложения вызывает массив определенного фиксированного размера (размер массива - константа времени компиляции), единственный правильный способ передать такой массив функции - использовать параметр указатель-массив

void foo(char (*p)[10]);

( на языке C ++ это также делается со ссылками

void foo(char (&p)[10]);

).

Это позволит проверить тип уровня на уровне языка, который обеспечит доставку массива точно правильного размера как аргумент. Фактически, во многих случаях люди используют этот метод неявно, даже не осознавая этого, скрывая тип массива за именем typedef

typedef int Vector3d[3];

void transform(Vector3d *vector);
/* equivalent to `void transform(int (*vector)[3])` */
...
Vector3d vec;
...
transform(&vec);

Обратите внимание, что приведенный выше код является инвариантным по отношению к типу Vector3d являющийся массивом или struct. Вы можете в любой момент переключить определение Vector3d с массива на struct и обратно, и вам не придется изменять объявление функции. В любом случае функции получат совокупный объект «по ссылке» (есть исключения из этого, но в контексте этого обсуждения это верно).

Однако вы не увидите этот метод Передача массива слишком часто используется слишком просто, потому что слишком много людей путают довольно запутанный синтаксис и просто не достаточно удобны с такими функциями языка C, чтобы правильно их использовать. По этой причине, в средней реальной жизни, передача массива в качестве указателя на его первый элемент является более популярным подходом. Это просто выглядит «проще».

Но на самом деле использование указателя на первый элемент для передачи массива - это очень нишевая техника, трюк, который служит очень конкретной цели: его единственная цель - для облегчения прохождения массивов разного размера (т. е. времени выполнения). Если вам действительно нужно иметь возможность обрабатывать массивы времени выполнения, то правильный способ передать такой массив - это указатель на его первый элемент с конкретным размером, предоставленным дополнительным параметром

void foo(char p[], unsigned plen);

Во многих случаях очень полезно иметь возможность обрабатывать массивы времени выполнения, что также способствует популярности метода. Многие разработчики C просто никогда не сталкиваются (или не признают) необходимость обрабатывать массив фиксированного размера, тем самым оставаясь не обратившись к правильной технике фиксированного размера.

Тем не менее, если размер массива фиксирован, передача его как указатель на элемент

void foo(char p[])

, является важной погрешностью на уровне техники, которая, к сожалению, довольно распространена в наши дни. Метод-указатель к массиву - гораздо лучший подход в таких случаях.

Еще одна причина, которая может помешать принятию метода передачи массива фиксированного размера, - это доминирование наивного подхода к набору динамически распределенных массивов , Например, если программа вызывает фиксированные массивы типа char[10] (как в вашем примере), средний разработчик будет malloc такими массивами, как

char *p = malloc(10 * sizeof *p);

Этот массив не может быть передан функции объявленный как

void foo(char (*p)[10]);

, который смущает среднего разработчика и заставляет их отказаться от объявления параметра фиксированного размера, не давая ему дальнейших размышлений. В действительности же корень проблемы кроется в наивном подходе malloc. Формат malloc, показанный выше, должен быть зарезервирован для массивов времени выполнения. Если тип массива имеет размер времени компиляции, лучший способ malloc выглядел бы следующим образом

char (*p)[10] = malloc(sizeof *p);

Это, конечно же, можно легко передать выше объявленному foo

foo(p);

, и компилятор выполнит правильную проверку типа. Но опять же, это чересчур запутывает неподготовленного разработчика C, поэтому вы не увидите его слишком часто в «типичном» среднем ежедневном коде.

Ну, просто положите, C не делает так. Массив типа T передается как указатель на первый T в массиве, и это все, что вы получаете.

Это позволяет использовать некоторые классные и элегантные алгоритмы, например, массив с выражениями типа

*dst++ = *src++

Недостатком является то, что управление размером зависит от вас. К сожалению, неспособность сделать это добросовестно также привела к миллионам ошибок в кодировании C и / или возможностях для злонамеренной эксплуатации.

Что близко к тому, что вы просите в C, - это пройти через struct (по значению) или указатель на один (по ссылке). Пока один и тот же тип структуры используется с обеих сторон этой операции, оба кода, которые передают ссылку и код, который ее использует, согласуются с размером обрабатываемых данных.

Ваш struct может содержать любые данные, которые вы хотите; он может содержать ваш массив четко определенного размера.

Тем не менее, ничто не мешает вам или некомпетентному или злонамеренному кодеру использовать приведения, чтобы обмануть компилятор, рассматривая вашу структуру как один из разного размера. Почти нераскрытая способность делать такие вещи является частью дизайна C.

Очевидная причина заключается в том, что этот код не компилируется:

extern void foo(char (*p)[10]);
void bar() {
  char p[10];
  foo(p);
}

По умолчанию для массива используется неквалифицированный указатель.

Также см. this вопрос , используя foo(&p), должен работать.

Возможно, я что-то пропустил, но ... поскольку массивы являются постоянными указателями, в основном это означает, что нет никакого смысла в обходе вокруг указателей.

Не могли бы вы просто использовать void foo(char p[10], int plen); ?

В моем компиляторе (vs2008) он рассматривает char (*p)[10] как массив указателей на символы, как если бы не было круглых скобок, даже если я скомпилирован как файл C. Поддерживает ли компилятор эту «переменную»? Если это так, это основная причина не использовать его.

Я также хочу использовать этот синтаксис для большей проверки типов.

Но я также согласен с тем, что синтаксис и ментальная модель использования указателей проще и легче запомнить.

Вот еще некоторые препятствия, с которыми я столкнулся.

• Доступ к массиву требует использования (*p)[]:

  void foo(char (*p)[10])
  {
      char c = (*p)[3];
      (*p)[0] = 1;
  }
  

  Вместо этого возникает соблазн использовать локальный указатель на символ:

  void foo(char (*p)[10])
  {
      char *cp = (char *)p;
      char c = cp[3];
      cp[0] = 1;
  }
  

  Но это частично превзойдет цель использования правильного типа.
• Нельзя забывать использовать адрес-оператор при назначении адреса массива указателю на массив:

  char a[10];
  char (*p)[10] = &a;
  

  Адрес- оператора получает адрес всего массива в &a, с правильным типом, чтобы назначить его p. Без оператора a автоматически преобразуется в адрес первого элемента массива, как и в &a[0], который имеет другой тип. Поскольку это автоматическое преобразование уже происходит, я всегда озадачен тем, что & необходим. Это согласуется с использованием & для переменных других типов, но я должен помнить, что массив является особым и мне нужен &, чтобы получить правильный тип адреса, хотя значение адреса одинаково , Одной из причин моей проблемы может быть то, что я узнал K & amp; R C еще в 80-х годах, что еще не позволило использовать оператор & на всех массивах (хотя некоторые компиляторы игнорировали это или допускали синтаксис). Это, кстати, может быть еще одной причиной, по которой переходы с привязками трудно принять: они работают только с ANSI C, а ограничение оператора & может быть еще одной причиной считать их слишком неудобными.
• Когда typedef является not , используемым для создания типа для указателя на массив (в общем заголовочном файле), тогда глобальный указатель на массив должен более сложная декларация extern для обмена ею между файлами:

  fileA:
  char (*p)[10];
  
  fileB:
  extern char (*p)[10];
  

Я бы не рекомендовал это решение

typedef int Vector3d[3];

, поскольку он скрывает тот факт, что Vector3D имеет тип, о котором вы должны знать. Программисты обычно не ожидают, что переменные того же типа будут иметь разные размеры. Рассмотрим:

void foo(Vector3d a) {
   Vector3D b;
}

, где sizeof a! = Sizeof b

Вы можете объявить массив символов несколькими способами:

char p[10];
char* p = (char*)malloc(10 * sizeof(char));

Прототипом функции, которая принимает массив по значению, является:

void foo(char* p); //cannot modify p

или reference:

void foo(char** p); //can modify p, derefernce by *p[0] = 'f';

или синтаксисом массива:

void foo(char p[]); //same as char*