Глава 4

Функции и Файлы

Итерация свойственна человеку, рекурсия божественна. - Л. Питер Дойч

4.1 Введение

4.2 Компоновка

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

  // file1.c:
      int a = 1;
      int f() { /* что-то делает */ }
  // file2.c:
      extern int a;
      int f();
      void g() { a = f(); }

a и f(), используемые g() в файле file2.c,- те же, что определены в файле file1.c. Ключевое слово extern (внешнее) указывает, что описание a в file2.c является (только) описанием, а не определением. Если бы a инициализировалось, extern было бы просто проигнорировано, поскольку описание с инициализацией всегда является определением. Объект в программе должен определяться только один раз. Описываться он может много раз, но типы должны точно согласовываться. Например:

  // file1.c:
      int a = 1;
      int b = 1;
      extern int c;
  // file2.c:
      int a;
      extern double b;
      extern int c;

Здесь три ошибки: a определено дважды (int a; является определением, которое означает int a=0;), b описано дважды с разными типами, а c описано дважды, но не определено. Эти виды ошибок (ошибки компоновки) не могут быть обнаружены компилятором, который за один раз видит только один файл. Компоновщик, однако, их обнаруживает.
Следующая программа не является C++ программой (хотя C программой является):

  // file1.c:
      int a;
      int f() { return a; }
  // file2.c:
      int a;
      int g() { return f(); }

Во-первых, file2.c не C++, потому что f() не была описана, и поэтому компилятор будет недоволен. Во-вторых, (когда file2.c фиксирован) программа не будет скомпонована, поскольку a определено дважды.
Имя можно сделать локальным в файле, описав его static. Например:

  // file1.c:
      static int a = 6;
      static int f() { /* ... */ }
  // file2.c:
      static int a = 7;
      static int f() { /* ... */ }

Поскольку каждое a и f описано как static, получающаяся в результате программа является правильной. В каждом файле своя a и своя f().
Когда переменные и функции явно описаны как static, часть программы легче понять (вам не надо никуда больше заглядывать). Использование static для функций может, помимо этого, выгодно влиять на расходы по вызову функции, поскольку дает оптимизирующему компилятору более простую работу.
Рассмотрим два файла:

  // file1.c:
      const int a = 6;
      inline int f() { /* ... */ }
      struct s { int a,b; }
  // file1.c:
      const int a = 7;
      inline int f() { /* ... */ }
      struct s { int a,b; }

4.3 Заголовочные Файлы

4.3.1 Один Заголовочный Файл

Проще всего решить проблему разбиения программы на несколько файлов поместив функции и определения данных в подходящее число исходных файлов и описав типы, необходимые для их взаимодействия, в одном заголовочном файле, который включается во все остальные файлы. Для программы калькулятора можно использовать четыре .c файла: lex.c, syn.c, table.c и main.c, и заголовочный файл dc.h, содержащий описания всех имен, которые используются более чем в одном .c файле:

  // dc.h: общие описания для калькулятора
  enum token_value {
      NAME,    NUMBER,    END,
      PLUS='+',    MINUS='-',    MUL='*',    DIV='/',
      PRINT=';',    ASSIGN='=',    LP='(',    RP=')'
  };
  extern int no_of_errors;
  extern double error(char* s);
  extern token_value get_token();
  extern token_value curr_tok;
  extern double number_value;
  extern char name_string[256];
  extern double expr();
  extern double term();
  extern double prim();
  struct name {
      char* string;
      name* next;
      double value;
  };
  extern name* look(char* p, int ins = 0);
  inline name* insert(char* s) { return look(s,1); }

Если опустить фактический код, то lex.c будет выглядеть примерно так:

  // lex.c: ввод и лексический анализ
  #include "dc.h"
  #include
  token_value curr_tok;
  double number_value;
  char name_string[256];
  token_value get_token() { /* ... */ }

Заметьте, что такое использование заголовочных файлов гарантирует, что каждое описание в заголовочном файле объекта, определенного пользователем, будет в какой-то момент включено в файл, где он определяется. Например, при компиляции lex.c компилятору будет передано:

  extern token_value get_token();
  // ...
  token_value get_token() { /* ... */ }

Это обеспечивает то, что компилятор обнаружит любую несогласованность в типах, указанных для имени. Например, если бы get_token() была описана как возвращающая token_value, но при этом определена как возвращающая int, компиляция lex.c не прошла бы из- за ошибки несоответствия типов.
Файл syn.c будет выглядеть примерно так:

  // syn.c: синтаксический анализ и вычисление
  #include "dc.h"
  double prim() { /* ... */ }
  double term() { /* ... */ }
  double expr() { /* ... */ }

Файл table.c будет выглядеть примерно так:

  // table.c: таблица имен и просмотр
  #include "dc.h"
  extern char* strcmp(const char*, const char*);
  extern char* strcpy(char*, const char*);
  extern int strlen(const char*);
  const TBLSZ = 23;
  name* table[TBLSZ];
  name* look(char* p; int ins) { /* ... */ }

Заметьте, что table.c сам описывает стандартные функции для работы со строками, поэтому никакой проверки согласованности этих описаний нет. Почти всегда лучше включать заголовочный файл, чем описывать имя в .c файле как extern. При этом может включаться "слишком много", но это обычно не оказывает серьезного влияния на время, необходимое для компиляции, и как правило экономит время программиста. В качестве примера этого, обратите внимание на то, как strlen() заново описывается в main() (ниже). Это лишние нажатия клавиш и возможный источник неприятностей, поскольку компилятор не может проверить согласованность этих двух определений. На самом деле, этой сложности можно было бы избежать, будь все описания extern помещены в dc.h, как и предлагалось сделать. Эта "небрежность" сохранена в программе, поскольку это очень типично для C программ, очень соблазнительно для программиста, и чаще приводит, чем не приводит, к ошибкам, которые трудно обнаружить, и к программам, с которыми тяжело работать. Вас предупредили!
И main.c, наконец, выглядит так:

  // main.c: инициализация, главный цикл и обработка ошибок
  #include "dc.h"
  int no_of_errors;
  double error(char* s) { /* ... */ }
  extern int strlen(const char*);
  main(int argc, char* argv[]) { /* ... */ }

4.3.2 Множественные Заголовочные Файлы

Стиль разбиения программы с одним заголовочным файлом наиболее пригоден в тех случаях, когда программа невелика и ее части не предполагается использовать отдельно. Поэтому то, что невозможно установить, какие описания зачем помещены в заголовочный файл, несущественно. Помочь могут комментарии. Другой способ - сделать так, чтобы каждая часть программы имела свой заголовочный файл, в котором определяются предоставляемые этой частью средства. Тогда каждый .c файл имеет соответствующий .h файл, и каждый .c файл включает свой собственный (специфицирующий то, что в нем задается) .h файл и, возможно, некоторые другие .h файлы (специфицирующие то, что ему нужно).
Рассматривая организацию калькулятора, мы замечаем, что error() используется почти каждой функцией программы, а сама использует только . Это обычная для функции ошибок ситуация, поэтому error() следует отделить от main():

  // error.h: обработка ошибок
  extern int no_errors;
  extern double error(char* s);
  // error.c
  #include
  #include "error.h"
  int no_of_errors;
  double error(char* s) { /* ... */ }

При таком стиле использования заголовочных файлов .h файл и связанный с ним .c файл можно рассматривать как модуль, в котором .h файл задает интерфейс, а .c файл задает реализацию.
Таблица символов не зависит от остальной части калькулятора за исключением использования функции ошибок. Это можно сделать явным:

  // table.h: описания таблицы имен
  struct name {
      char* string;
      name* next;
      double value;
  };
  extern name* look(char* p, int ins = 0);
  inline name* insert(char* s) { return look(s,1); }
  // table.c: определения таблицы имен
  #include "error.h"
  #include
  #include "table.h"
  const TBLSZ = 23;
  name* table[TBLSZ];
  name* look(char* p; int ins) { /* ... */ }

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

  // lex.h: описания для ввода и лексического анализа
  enum token_value {
      NAME,        NUMBER,        END,
      PLUS='+',    MINUS='-',     MUL='*',    DIV='/',
      PRINT=';',   ASSIGN='=',    LP='(',     RP=')'
  };
  extern token_value curr_tok;
  extern double number_value;
  extern char name_string[256];
  extern token_value get_token();

Этот интерфейс лексического анализатора достаточно беспорядочен. Недостаток в надлежащем типе лексемы обнаруживает себя в необходимости давать пользователю get_token() фактические лексические буферы number_value и name_string.

  // lex.c: определения для ввода и лексического анализа
  #include
  #include
  #include "error.h"
  #include "lex.h"
  token_value curr_tok;
  double number_value;
  char name_string[256];
  token_value get_token() { /* ... */ }

Интерфейс синтаксического анализатора совершенно прозрачен:

  // syn.c: описания для синтаксического анализа и вычисления
  extern double expr();
  extern double term();
  extern double prim();
  // syn.c: определения для синтаксического анализа и вычисления
  #include "error.h"
  #include "lex.h"
  #include "syn.h"
  double prim() { /* ... */ }
  double term() { /* ... */ }
  double expr() { /* ... */ }

Главная программа, как всегда, тривиальна:

  // main.c: главная программа
  #include
  #include "error.h"
  #include "lex.h"
  #include "syn.h"
  #include "table.h"
  #include
  main(int argc, char* argv[]) { /* ... */ }

4.3.3 Скрытие Данных

Используя заголовочные файлы пользователь может определять явный интерфейс, чтобы обеспечить согласованное использование типов в программе. С другой стороны, пользователь может обойти интерфейс, задаваемый заголовочным файлом, вводя в .c файлы описания extern.
Заметьте, что такой стиль компоновки не рекомендуется:

  // file1.c:                // "extern" не используется
      int a = 7;
      const c = 8;
      void f(long) { /* ... */ }
  // file2.c:                // "extern" в .c файле
      extern int a;
      extern const c;
      extern f(int);
      int g() { return f(a+c); }

Поскольку описания extern в file2.c не включаются вместе с определениями в файле file1.c, компилятор не может проверить согласованность этой программы. Следовательно, если только загрузчик не окажется гораздо сообразительнее среднего, две ошибки в этой программе останутся, и их придется искать программисту.
Пользователь может защитить файл от такой недисциплинированной компоновки, описав имена, которые не предназначены для общего пользования, как static, чтобы их областью видимости был файл, и они были скрыты от остальных частей программы. Например:

  // table.c: определения таблицы имен
  #include "error.h"
  #include
  #include "table.h"
  const TBLSZ = 23;
  static name* table[TBLSZ];
  name* look(char* p; int ins) { /* ... */ }

4.4 Файлы как Модули

4.5 Как Создать Библиотеку

Фразы типа "помещен в библиотеку" и "ищется в какой-то библиотеке" используются часто (и в этой книге, и в других), но что это означает для C++ программы? К сожалению, ответ зависит от того, какая операционная система используется; в этом разделе объясняется, как создать библиотеку в 8-ой версии системы UNIX. Другие системы предоставляют аналогичные возможности.
Библиотека в своей основе является множеством .o файлов, полученных в результате компиляции соответствующего множества .c файлов. Обычно имеется один или более .h файлов, в которых содержатся описания для использования этих .o файлов. В качестве примера рассмотрим случай, когда нам надо задать (обычным способом) набор математических функций для некоторого неопределенного множества пользователей. Заголовочный файл мог бы выглядеть примерно так:

  extern double sqrt(double);        // подмножество
  extern double sin(double);
  extern double cos(double);
  extern double exp(double);
  extern double log(double);

а определения этих функций хранились бы, соответственно, в файлах sqrt.c, sin.c, cos.c, exp.c и log.c.
Библиотеку с именем math.h можно создать, например, так:

  $ CC -c sqrt.c sin.c cos.c exp.c log.c
  $ ar cr math.a sqrt.o sin.o cos.o exp.o log.o
  $ ranlib math.a

Вначале исходные файлы компилируются в эквивалентные им объектные файлы. Затем используется команда ar, чтобы создать архив с именем math.a. И, наконец, этот архив индексируется для ускорения доступа. Если в вашей системе нет команды runlib, значит она вам, вероятно, не понадобится. Подробности посмотрите, пожалуйста, в вашем руководстве в разделе под заголовком ar. Использовать библиотеку можно, например, так:

  $ CC myprog.c math.a

Теперь разберемся, в чем же преимущества использования math.a перед просто непосредственным использованием .o файлов? Например:

  $ CC myprog.c sqrt.o sin.o cos.o exp.o log.o

Для большинства программ определить правильный набор .o файлов, несомненно, непросто. В приведенном выше примере они включались все, но если функции в myprog.c вызывают только функции sqrt() и cos(), то кажется, что будет достаточно

  $ CC myprog.c sqrt.o cos.o

4.6 Функции

4.6.1 Описания Функций

Описание функции задает имя функции, тип возвращаемого функцией значения (если таковое есть) и число и типы параметров, которые должны быть в вызове функции. Например:

  extern double sqrt(double);
  extern elem* next_elem();
  extern char* strcpy(char* to, const char* from);
  extern void exit(int);

Семантика передачи параметров идентична семантике инициализации. Проверяются типы параметров, и когда нужно производится неявное преобразование типа. Например, если были заданы предыдущие определения, то

  double sr2 = sqrt(2);

4.6.2 Определения Функций

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

  extern void swap(int*, int*);    // описание
  void swap(int*, int*)            // определение
  {
      int t = *p;
      *p =*q;
      *q = t;
  }

4.6.3 Передача Параметров

4.6.4 Возврат Значения

Из функции, которая не описана как void, можно (и должно) возвращать значение. Возвращаемое значение задается оператором return. Например:

  int fac(int n) {return (n>1) ? n*fac(n-1) : 1; }

В функции может быть больше одного оператора return:

  int fac(int n)
  {
      if (n > 1)
          return n*fac(n-1);
      else
          return 1;
  }

Как и семантика передачи параметров, семантика возврата функцией значения идентична семантике инициализации. Возвращаемое значение рассматривается как инициализатор переменной возвращаемого типа. Тип возвращаемого выражения проверяется на согласованность с возвращаемым типом и выполняются все стандартные и определенные пользователем преобразования типов. Например:

  double f()
  {
      // ...
      return 1;    // неявно преобразуется к double(1)
  }

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

  int* f() {
      int local = 1;
      // ...
      return &local;            // так не делайте
  }

Эта ошибка менее обычна, чем эквивалентная ошибка при использовании ссылок:

  int& f() {
      int local = 1;
      // ...
      return local;            // так не делайте
  }

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

  int& f() { return 1;}        // так не делайте

4.6.5 Векторные Параметры

Если в качестве параметра функции используется вектор, то передается указатель на его первый элемент. Например:

  int strlen(const char*);
  void f()
  {
      char v[] = "a vector"
      strlen(v);
      strlen("Nicholas");
  };

Иначе говоря, при передаче как параметр типа T[] преобразуется к T*. Следовательно, присваивание элементу векторного параметра изменяет значение элемента вектора, который является параметром. Другими словами, вектор отличается от всех остальных типов тем, что вектор не передается (и не может передаваться) по значению.
Размер вектора недоступен вызываемой функции. Это может быть неудобно, но эту сложность можно обойти несколькими способами. Строки оканчиваются нулем, поэтому их размер можно легко вычислить. Для других векторов можно передавать второй параметр, который задает размер, или определить тип, содержащий указатель и индикатор длины, и передавать его вместо просто вектора (см. также #1.11). Например:

  void compute1(int* vec_ptr, int vec_size);    // один способ
  struct vec {                                  // другой способ
      int* ptr;
      int size;
  };
  void compute2(vec v);

С многомерными массивами все хитрее, но часто можно вместо них использовать векторы указателей, которые не требуют специального рассмотрения. Например:

  char* day[] = {
      "mon", "tue", "wed", "thu", "fri", "sat", "sun"
  };

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

  void print_m34(int m[3][4])
  {
      for (int i = 0; i<3; i++) { for (int j="0;" j<4; j++) cout << " " << m[i][j]; cout << "\n"; } } 

4.6.6 Параметры по Умолчанию

Часто в самом общем случае функции требуется больше параметров, чем в самом простом и более употребительном случае. Например, в библиотеке потоков есть функция hex(), порождающая строку с шестнадцатиричным представлением целого. Второй параметр используется для задания числа символов для представления первого параметра. Если число символов слишком мало для представления целого, происходит усечение, если оно слишком велико, то строка дополняется пробелами. Часто программист не заботится о числе символов, необходимых для представления целого, поскольку символов достаточно. Поэтому для нуля в качестве второго параметра определено значение "использовать столько символов, сколько нужно". Чтобы избежать засорения программы вызовами вроде hex(i,0), функция описывается так:

  extern char* hex(long, int =0);

Инициализатор второго  параметра является  параметром по умолчанию.
То есть, если в вызове дан только один параметр, в качестве второго
используется параметр по умолчанию. Например:

  cout << "**" << hex(31) << hex(32,3) << "**"; 

  cout << "**" << hex(31,0) << hex(32,3) << "**"; 

  ** 1f 20**

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

  int f(int, int =0, char* =0);    // ok
  int g(int =0, int =0, char*);    // ошибка
  int f(int =0, int, char* =0);    // ошибка

Заметьте, что  в  этом  контексте  пробел  между  *  и  =  является
существенным (*= является операцией присваивания):

  int nasty(char*=0);                // синтаксическая ошибка

4.6.7 Перегрузка Имен Функций

Как правило, давать разным функциям разные имена - мысль хорошая, но когда некоторые функции выполняют одинаковую работу над объектами разных типов, может быть более удобно дать им одно и то же имя. Использование одного имени для различных действий над различными типами называется перегрузкой (overloading). Метод уже используется для основных операций C++: у сложения существует только одно имя, +, но его можно применять для сложения значений целых, плавающих и указательных типов. Эта идея легко расширяется на обработку операций, определенных пользователем, то есть, функций. Чтобы уберечь программиста от случайного повторного использования имени, имя может использоваться более чем для одной функции только если оно сперва описано как перегруженное. Например:

  overload print;
  void print(int);
  void print(char*);

4.6.8 Незаданное Число Параметров

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

  int printf(char* ...);

  Это задает,  что в вызове printf должен быть по меньшей мере один
параметр, char*,  а остальные  могут  быть,  а  могут  и  не  быть.
Например:

  printf("Hello, world\n");
  printf("Мое имя %s %s\n", first_name, second_name);
  printf("%d + %d = %d\n",2,3,5);

  Такая  функция   полагается  на  информацию,  которая  недоступна
компилятору  при  интерпретации  ее  списка  параметров.  В  случае
printf() первым  параметром  является  строка  формата,  содержащая
специальные  последовательности   символов,  позволяющие   printf()
правильно  обрабатывать   остальные  параметры.  %s  означает  "жди
параметра char*",  а  %d  означает  "жди  параметра  int".  Однако,
компилятор этого не знает, поэтому он не может убедиться в том, что
ожидаемые параметры имеют соответствующий тип. Например:

  printf("Мое имя %s %s\n",2);

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

  Очевидно, если  параметр не  был описан,  то  у  компилятора  нет
информации, необходимой  для выполнения  над ним  проверки  типа  и
преобразования типа.  В этом  случае char  или short передаются как
int, а  float передается  как double.  Это не  обязательно то, чего
ждет пользователь.

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

  extern int fprintf(FILE*, char* ...);    // из
  extern int execl(char* ...);             // из
  extern int  abort(...);                  // из

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

  void error(int ...);
  main(int argc, char* argv[])
  {
      switch(argc) {
      case 1:
          error(0,argv[0],0);
          break;
      case 2:
          error(0,argv[0],argv[1],0);
      default:
          error(1,argv[0],"с",dec(argc-1),"параметрами",0);
      }
  }

  Функцию ошибок можно определить так:

  #include
  void error(int n ...)
  /*
      "n" с последующим списком char*, оканчивающихся нулем
  */
  {
      va_list ap;
      va_start(ap,n);            // раскрутка arg
      for (;;) {
      char* p = va_arg(ap,char*);
      if(p == 0) break;
      cerr << p << " "; } va_end(ap); // очистка arg cerr << "\n"; if (n) exit(n); } 

4.6.9 Указатель на Функцию

С функцией можно делать только две вещи: вызывать ее и брать ее адрес. Указатель, полученный взятием адреса функции, можно затем использовать для вызова этой функции. Например:

  void error(char* p) { /* ... */ }
  void (*efct)(char*);                // указатель на функцию
  void f()
  {
      efct = &error;                  // efct указывает на error
      (*efct)("error");               // вызов error через efct
  }

Чтобы вызвать функцию через указатель, например, efct, надо сначала
этот  указатель  разыменовать,  *efct.  Поскольку  операция  вызова
функции  ()   имеет   более   высокий   приоритет,   чем   операция
разыменования  *,  то  нельзя  писать  просто  *efct("error").  Это
означает *efct("error"),  а это  ошибка в типе. То же относится и к
синтаксису  описаний (см. также #7.3.4).

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

  void (*pf)(char*);        // указатель на void(char*)
  void f1(char*);           // void(char*)
  int  f2(char*);           // int(char*)
  void f3(int*);            // void(int*)
  void f()
  {
      pf = &f1;             // ok
      pf = &f2;             // ошибка: не подходит возвращаемый тип
      pf = &f3;             // ошибка: не подходит тип параметра
      (*pf)("asdf");        // ok
      (*pf)(1);             // ошибка: не подходит тип параметра
      int i = (*pf)("qwer"); // ошибка: void присваивается int'у
  }

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

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

  typedef int (*SIG_TYP)();        // из
  typedef void (*SIG_ARG_TYP);
  SIG_TYP signal(int,SIG_ARG_TYP);

4.7 Макросы

4.8 Упражнения