Глава 4

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

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

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

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

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

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

  // 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: ввод и лексический анализ
  #include "dc.h"
  #include
  token_value curr_tok;
  double number_value;
  char name_string[256];
  token_value get_token() { /* ... */ }

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

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

  // 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) { /* ... */ }

  // 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) { /* ... */ }

  // 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();

  // 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); }

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

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

Фразы типа "помещен в библиотеку" и "ищется в какой-то библиотеке" используются часто (и в этой книге, и в других), но что это означает для 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);

  $ 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

  $ CC myprog.c math.a

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

  $ CC myprog.c sqrt.o cos.o

4.6 Функции

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

  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; }

  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");
  };

  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("Hello, world\n");
  printf("Мое имя %s %s\n", first_name, second_name);
  printf("%d + %d = %d\n",2,3,5);

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

  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
  }

  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 Упражнения