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

void print_int(int);            /* печать целого числа int */

void print_string(const char*); /* печать строки */

Иногда это свойство называют преимуществом: теперь вы не сможете случайно использовать неправильную функцию для вывода целого числа! Очевидно, что нас такой аргумент убедить не сможет, а отсутствие перегруженных функций усложняет реализацию идей обобщенного программирования, поскольку они основаны на семантически похожих функциях, имеющих одинаковые имена. 

27.2.2. Проверка типов аргументов функций

Рассмотрим следующий пример:

int main()

{

  f(2);

}

К сожалению, это определение в другом исходном файле может выглядеть следующим образом:

/* other_file.c: */

int f(char* p)

{

  int r = 0;

  while (*p++) r++;

  return r;

}

Редактор связей не сообщит об этой ошибке. Вместо этого вы получите ошибку на этапе выполнения программы или случайный результат.

Вы можете попросить включить проверку аргументов функций в языке С. Для этого достаточно объявить функцию с заданными типами аргументов (точно так же, как в языке С++). Такое объявление называется прототипом функции (function prototype). Тем не менее следует избегать объявлений, не задающих аргументы; они не являются прототипами функций и не включают механизм проверки типов.

int g(double); /* прототип — как в языке С ++ */

int h();       /* не прототип — типы аргументов не указаны */

void my_fct()

{

  g();       /* ошибка: пропущен аргумент */

  g("asdf"); /* ошибка: неправильный тип аргумента */

  g(2);      /* OK: 2 преобразуется в 2.0 */

  g(2,3);    /* ошибка: один аргумент лишний */

  h();       /* Компилятор допускает! Результат непредсказуем */

  h("asdf"); /* Компилятор допускает! Результат непредсказуем */

  h(2);      /* Компилятор допускает! Результат непредсказуем */

  h(2,3);    /* Компилятор допускает! Результат непредсказуем */

}

Существует специальный набор правил, регламентирующих преобразование аргументов, если в области видимости нет прототипа функции. Например, переменные типов char и short преобразуются в переменные типа int, а переменные типа float — в переменные типа double. Если вы хотите знать, скажем, что произойдет с переменной типа long, загляните в хороший учебник по языку С. Наша рекомендация проста: не вызывайте функций, не имеющих прототипов.

Обратите внимание на то, что, хотя компилятор допускает передачу аргументов неправильного типа, например параметр типа char* вместо параметра типа int, использование таких аргументов приводит к ошибкам. Как сказал Деннис Ритчи: “С — это язык программирования со строгим контролем типов и слабой проверкой”.

27.2.3. Определения функций

Можете определять функции точно так же, как в языке С++. Эти определения являются прототипами функций.

double square(double d)

{

  return d*d;

}

void ff()

{

  double x = square(2);       /* OK: переводим 2 в 2.0 и вызываем */

  double y = square();        /* пропущен аргумент */

  double y = square("Hello"); /* ошибка: неправильный тип

                                 аргументов */

 double y = square(2,3);      /* ошибка: слишком много аргументов */

}

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

void f() { /* что-то делает */ }

void g()

{

  f(2);    /* OK в языке C; ошибка в языке C++ */

}

Код

void f();  /* не указан тип аргумента */

означающий, что функция f() может принять любое количество аргументов любого типа, выглядит действительно странно. В ответ на это я изобрел новое обозначение, в котором понятие “ничего” указывалось явным образом с помощью ключевого слова void (void — слово из четырех букв, означающее “ничего”).

void f(void); /* не принимает никаких аргументов */