Почему компилируется функция без параметров (по сравнению с фактическим определением функции)?

Я только что натолкнулся на чей-то C-код, который меня смущает, почему он компилируется. Есть два момента, которые я не понимаю.

Во-первых, прототип функции не имеет параметров по сравнению с фактическим определением функции. Во-вторых, параметр в определении функции не имеет типа.

#include <stdio.h>

int func();

int func(param)
{
    return param;
}

int main()
{
    int bla = func(10);    
    printf("%d", bla);
}

Почему это работает? Я проверил его в нескольких компиляторах, и он отлично работает.

Все остальные ответы верны, но только для завершения

Функция объявляется следующим образом:

  return-type function-name(parameter-list,...) { body... }

return-type - тип переменной, которую возвращает функция. Это не может быть тип массива или тип функции. Если не дано, то предполагается, что int .

имя-функции - это имя функции.

Параметр-список - это список параметров, которые функция принимает через запятую. Если параметры не заданы, функция не принимает и должна быть определена с пустым набором скобок или ключевым словом void. Если тип переменной не находится перед переменной в списке параметров, то предполагается использование int . Массивы и функции не передаются в функции, но автоматически преобразуются в указатели. Если список заканчивается многоточием (, ...), то количество параметров не устанавливается. Примечание: заголовок stdarg.h может использоваться для доступа к аргументам при использовании многоточия.

И снова ради полноты. Из спецификации C11 6: 11: 6 (стр: 179)

Использование функции declarators с пустыми скобками (не прототип формат declarators типа параметра) является устаревшим особенность .

В С func()означает, что вы можете передать любое количество аргументов. Если вы не хотите аргументов, вы должны объявить как func(void). Тип, который вы передаете своей функции, если не указан, по умолчанию int.

int func();является устаревшим объявлением функции со времен, когда не было стандарта C, т.е. дней K & R C (до 1989 года, когда был опубликован первый стандарт "ANSI C").

Помните, что в K & R C не было прототипов, а ключевое слово voidеще не было изобретено. Все, что вы могли сделать, это сообщить компилятору о типе возвращаемого значения функции. Пустой список параметров в K & R C означает «неопределенное, но фиксированное» количество аргументов. Фиксированный означает, что вы должны вызывать функцию с одинаковым количеством аргументов каждый раз (в отличие от функции с переменным числом, например printf, где число и тип могут варьироваться для каждого вызова).

Многие компиляторы будут диагностировать эту конструкцию; в частности gcc -Wstrict-prototypes, вам скажут, что «объявление функции не является прототипом», что очень важно, потому что выглядит как прототип (особенно если вы отравлены C ++!), но это не так. Это объявление типа возврата K & R C старого стиля.

Правило большого пальца. Никогда не оставляйте пустое объявление списка параметров пустым, используйте int func(void)для конкретности. Это превращает объявление возвращаемого типа K & R в правильный прототип C89. Компиляторы счастливы, разработчики счастливы, статические контролеры счастливы. Те, кто вводит в заблуждение ^ W ^ Wfond из C ++, могут съежиться, потому что им нужно вводить дополнительные символы, когда они пытаются использовать свои навыки иностранного языка :-)

• Пустой список параметров означает «любые аргументы», поэтому определение не является неправильным.
• Отсутствующий тип предполагается int.

Я бы посчитал, что в любой сборке, в которой это происходит, не хватает настроенного уровня предупреждения / ошибки, хотя нет никакого смысла в том, чтобы это учитывало фактический код.

Это объявление и определение функции в стиле K & R. От стандарта C99 (ISO / IEC 9899: TC3)

Раздел 6.7.5.3 Деклараторы функций (включая прототипы)

Список идентификаторов объявляет только идентификаторы параметров функции. Пустой список в деклараторе функции, который является частью определения этой функции, указывает на то, что функция не имеет параметров. Пустой список в объявителе функции, который не является частью определения этой функции, указывает на то, что информация о количестве или типах параметров не предоставляется. (Если оба типа функций «старого стиля», типы параметров не сравниваются.)

Раздел 6.11.6 Объявление функций

Использование деклараторов функций с пустыми скобками (не деклараторы типа параметров в формате prototype) является устаревшей функцией.

Раздел 6.11.7 Определения функций

Использование определений функций с отдельными идентификаторами параметров и списками объявлений (а не типом параметров прототипа и объявлениями идентификаторов) является устаревшей функцией.

Какой старый стиль означает K & R стиль

Пример:

Декларация: int old_style();

Определение:

int old_style(a, b)
    int a; 
    int b;
{
     /* something to do */
}

C предполагает, intчто тип не указан в типе возвращаемого значения функции и списке параметров . Только для этого правила возможны следующие странные вещи.

Определение функции выглядит следующим образом.

int func(int param) { /* body */}

Если его прототип вы пишете

int func(int param);

В прототипе вы можете указать только тип параметров. Имя параметра не обязательно. Так

int func(int);

Также, если вы не указываете тип параметра, но имя intпринимается как тип.

int func(param);

Если вы идете дальше, то тоже работает.

func();

Компилятор предполагает, int func()когда вы пишете func(). Но не помещайте func()в тело функции. Это будет вызов функции

Как сказал @Krishnabhadra, все предыдущие ответы других пользователей имеют правильную интерпретацию, и я просто хочу сделать более подробный анализ некоторых моментов.

В Old-C, как и в ANSI-C, « нетипизированный формальный параметр », возьмите измерение вашего рабочего регистра или возможности глубины команд (теневые регистры или совокупный цикл команд), в 8-битном MPU будет int16, в 16-битном MPU и так далее будет int16 и так далее, в случае, если 64-битные архитектуры могут выбрать компиляцию таких параметров, как: -m32.

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

В других случаях для некоторых микропроцессорных архитектур настраиваемые компиляторы ANSI использовали некоторые из этих старых функций для оптимизации использования кода, заставляя расположение этих «нетипизированных формальных параметров» работать внутри или вне рабочего регистра, сегодня вы получаете почти то же самое с использованием «volatile» и «register».

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

Примеры компиляции с gcc под linux:

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

Нравится:

int myfunc(int param);

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

компилируя вашу программу, используя gcc foo.c -Wextra:

foo.c: In function ‘func’:
foo.c:5:5: warning: type of ‘param’ defaults to ‘int’ [-Wmissing-parameter-type]

странно -Wextraне улавливает это clang(не распознает -Wmissing-parameter-typeпо какой-то причине, может быть, для исторических, упомянутых выше), но -pedanticделает:

foo.c:5:10: warning: parameter 'param' was not declared, 
defaulting to type 'int' [-pedantic]
int func(param)
         ^
1 warning generated.

А для проблемы с прототипом, как уже было сказано выше, это int func()относится к произвольным параметрам, если вы не определите их явно, так как int func(void)это даст вам ошибки, как и ожидалось:

foo.c: In function ‘func’:
foo.c:6:1: error: number of arguments doesn’t match prototype
foo.c:3:5: error: prototype declaration
foo.c: In function ‘main’:
foo.c:12:5: error: too many arguments to function ‘func’
foo.c:5:5: note: declared here

или clangкак:

foo.c:5:5: error: conflicting types for 'func'
int func(param)
    ^
foo.c:3:5: note: previous declaration is here
int func(void);
    ^
foo.c:12:20: error: too many arguments to function call, expected 0, have 1
    int bla = func(10);
              ~~~~ ^~
foo.c:3:1: note: 'func' declared here
int func(void);
^
2 errors generated.

Если объявление функции не имеет параметров, т. Е. Пусто, оно принимает неопределенное количество аргументов. Если вы хотите, чтобы он не принимал аргументов, измените его на:

int func(void);

Вот почему я обычно советую людям компилировать их код:

cc -Wmissing-variable-declarations -Wstrict-variable-declarations -Wold-style-definition

Эти флаги поддерживают несколько вещей:

• -Wmissing-variable-объявлений: Невозможно объявить нестатическую функцию без предварительного получения прототипа. Это повышает вероятность того, что прототип в заголовочном файле совпадает с фактическим определением. Кроме того, он принудительно добавляет ключевое слово static к функциям, которые не должны отображаться публично.
• -Wstrict-variable-объявлений: прототип должен правильно перечислять аргументы.
• Определение стиля: само определение функции должно также правильно перечислять аргументы.

Эти флаги также используются по умолчанию во многих проектах с открытым исходным кодом. Например, во FreeBSD эти флаги включены при сборке с WARNS = 6 в вашем Makefile.