Глава 3

Выражения и операторы

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

  r=2.5
  area=pi*r*r

  2.5
  19.635

3.1.1 Программа синтаксического разбора

Вот грамматика языка, допускаемого калькулятором:

  program:
      END                    // END - это конец ввода
      expr_list END
  expr_list:
      expression PRINT      // PRINT - это или '\n' или ';'
      expression PRINT expr_list
  expression:
      expression + term
      expression - term
      term
  term:
      term / primary
      term * primary
      primary
  primary:
      NUMBER                // число с плавающей точкой в C++
      NAME                  // имя C++ за исключением '_'
      NAME = expression
      - primary
      ( expression )

  enum token_value {
      NAME        NUMBER    END
      PLUS='+'    MINUS='-'    MUL='*'    DIV='/'
      PRINT=';'    ASSIGN='='    LP='('    RP=')'
  };
  token_value curr_tok;

  double expr()                   // складывает  и вычитает
  {
      double left = term();
      for(;;)                     // ``навсегда``
          switch(curr_tok) {
          case PLUS:
              get_token();        // ест '+'
              left += term();
              break;
          case MINUS:
              get_token();        // ест '-'
              left -= term();
              break;
          default:
              return left;
          }
  }

3.1.2 Функция ввода

Чтение ввода - часто самая запутанная часть программы. Причина в том, что если программа должна общаться с человеком, то она должна справляться с его причудами, условностями и внешне случайными ошибками. Попытки заставить человека вести себя более удобным для машины образом часто (и справедливо) рассматриваются как оскорбительные. Задача низкоуровневой программы ввода состоит в том, чтобы читать символы по одному и составлять из них лексические символы более высокого уровня. Далее эти лексемы служат вводом для программ более высокого уровня. У нас ввод низкого уровня осуществляется get_token(). Обнадеживает то, что написание программ ввода низкого уровня не является ежедневной работой; в хорошей системе для этого будут стандартные функции.
Для калькулятора правила ввода сознательно были выбраны такими, чтобы функциям по работе с потоками было неудобно эти правила обрабатывать; незначительные изменения в определении лексем сделали бы get_token() обманчиво простой.
Первая сложность состоит в том, что символ новой строки '\n' является для калькулятора существенным, а функции работы с потоками считают его символом пропуска. То есть, для этих функций '\n' значим только как ограничитель лексемы. Чтобы преодолеть это, надо проверять пропуски (пробел, символы табуляции и т.п.):

  char ch
  do {    // пропускает пропуски за исключением '\n'
      if(!cin.get(ch)) return curr_tok = END;
  } while (ch!='\n' && isspace(ch));

3.1.3 Таблица имен

К таблице имен доступ осуществляется с помощью одной функции

  name* look(char* p, int ins =0);

  inline name* insert(char* s) { return look(s,1);}

  srtuct name {
      char* string;
      char* next;
      double value;
  }

  const TBLSZ = 23;
  name* table[TBLSZ];

  int ii = 0;        // хэширование
  char* pp = p;
  while (*pp) ii = ii<<1 ^ *pp++;
  if (ii < 0) ii = -ii;
  ii %= TBLSZ;

  ii <<= 1;
  ii ^= *pp++;

  if (ii < 0) ii = -ii;
  ii %= TBLSZ;

  extern int strlen(const char*);
  extern int strcmp(const char*, const char*);
  extern int strcpy(const char*, const char*);
  name* look(char* p, int ins =0)
  {
      int ii = 0;        // хэширование
      char* pp = p;
      while (*pp) ii = ii<<1 ^ *pp++;
      if (ii < 0) ii = -ii;
      ii %= TBLSZ;
      for (name* n=table[ii]; n; n=n->next)    // поиск
          if (strcmp(p,n->string) == 0) return n;
      if (ins == 0) error("имя не найдено");
      name* nn = new name;                     // вставка
      nn->string = new char[strlen(p)+1];
      strcpy(nn->string,p);
      nn->value = 1;
      nn->next = table[ii];
      table[ii] = nn;
      return nn;
  }

3.1.4 Обработка ошибок

Поскольку программа так проста, обработка ошибок не составляет большого труда. Функция обработки ошибок просто считает ошибки, пишет сообщение об ошибке и возвращает управление обратно:

  int no_of_errors;
  double error(char* s) {
      cerr << "error: " << s << "\n";
      no_of_errors++;
      return 1;
  }

3.1.5 Драйвер

Когда все части программы на месте, нам нужен только драйвер для инициализации и всего того, что связано с запуском. В этом простом примере main() может работать так:

  int main()
  {
      // вставить предопределенные имена:
      insert("pi")->value = 3.1415926535897932385;
      insert("e")->value = 2.7182818284590452354;
      while (cin) {
          get_token();
          if (curr_tok == END) break;
          if (curr_tok == PRINT) continue;
          cout << expr() << "\n";
      }
      return no_of_errors;
  }

  cout << expr() << "\n";

  while (cin) {
      // ...
      if (curr_tok == PRINT) continue;
      cout << expr() << "\n";
  }

  while (cin) {
      // ...
      if (curr_tok == PRINT) goto end_of_loop;
      cout << expr() << "\n";
      end_of_loop
  }

3.1.6 Параметры командной строки

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

Как уже говорилось, программа запускается вызовом main(). Когда это происходит, main() получает два параметра: указывающий число параметров, обычно называемый argc, и вектор параметров, обычно называемый argv. Параметры - это символьные строки, поэтому argv имеет тип char*[argc]. Имя программы (так, как оно стоит в командной строке) передается в качестве argv[0], поэтому argc всегда не меньше единицы. Например, в случае команды

  dc 150/1.1934

  argc        2
  argv[0]        "dc"
  argv[1]        "150/1.1934"

3.2 Краткая сводка операций

Операции C++ подробно и систематически описываются в #с.7; прочитайте, пожалуйста, этот раздел. Здесь же приводится краткая сводка и некоторые примеры. После каждой операции приведено одно или более ее общеупотребительных названий и пример ее использования. В этих примерах имя_класса - это имя класса, член - имя члена, объект - выражение, дающее в результате объект класса, указатель - выражение, дающее в результате указатель, выр - выражение, а lvalue - выражение, денотирующее неконстантный объект. Тип может быть совершенно произвольным именем типа (со *, () и т.п.) только когда он стоит в скобках, во всех остальных случаях существуют ограничения.
Унарные операции и операции присваивания правоассоциативны, все остальные левоассоциативны. Это значит, что a=b=c означает a=(b=c), a+b+c означает (a+b)+c, и *p++ означает *(p++), а не (*p)++.

Сводка Операций (часть 1)

::        разрешение области видимости   имя_класса :: член
   ::        глобальное                     :: имя

Сводка Операций (часть 2)

3.2.1 Круглые скобки

Скобками синтаксис C++ злоупотребляет; количество способов их использования приводит в замешательство: они применяются для заключения в них параметров в вызовах функций, в них заключается тип в преобразовании типа (приведении к типу), в именах типов для обозначения функций, а также для разрешения конфликтов приоритетов. К счастью, последнее требуется не слишком часто, потому что уровни приоритета и правила ассоциативности определены таким образом, чтобы выражения "работали ожидаемым образом" (то есть, отражали наиболее привычный способ употребления). Например, значение

  if (i<=0 || max

3.2.2 Порядок вычисления

Порядок вычисления подвыражений в выражении не определен. Например

  int i = 1;
  v[i] = i++;

  ,    &&    ||

3.2.4 Побитовые логические операции

Побитовые логические операции

  &    |    ^    ~    >>    <<

  enum state_value { _good=0, _eof=1, _fail=2, _bad=4};
                   // хорошо, конец файла, ошибка, плохо

  cout.state = _good;

  if (cout.state&(_bad|_fail)) // не good

  cin.state |= _eof;

  cin.state = _eof;

  state_value diff = cin.state^cout.state;

3.2.5 Преобразование типа

Бывает необходимо явно преобразовать значение одного типа в значение другого. Явное преобразование типа дает значение одного типа для данного значения другого типа. Например:

  float r = float(1);

  char* p = (char*)0777;

  typedef char* Pchar;
  char* p = Pchar(0777);

  Pname n2 = Pbase(n1->tp)->b_name;        // функциональная запись
  Pname n3 = ((Pbase)n2->tp)->b_name;        // запись приведения к
  типу

  ((Pbase)(n2->tp))->b_name

  any_type* p = (any_type*)&some_object;

3.2.6 Свободная память

3.3 Сводка операторов

Операторы C++ систематически и полностью изложены в #с.9, прочитайте, пожалуйста, этот раздел. А здесь приводится краткая сводка и некоторые примеры.

Синтаксис оператора

   оператор:
       описание
       {список_операторов opt}
       выражение opt
       if ( выражение ) опреатор
       if ( выражение ) оператор else оператор
       switch ( выражение ) оператор
       while ( выражение ) оператор
       do оператор while (выражение)
       for ( оператор  выражение opt ; выражение opt ) оператор
       case константное_выражение : оператор
       default : оператор
       break ;
       continue ;
       return выражение opt ;
       goto идентификатор ;
       идентификатор : оператор
       список_операторов:
           оператор
           оператор список_операторов

3.3.1 Проверки

Проверка значения может осуществляться или оператором if, или оператором switch:

  if ( выражение ) оператор
  if ( выражение ) оператор else оператор
  switch ( выражение ) оператор

  ==    !=    <    <=    >    >=

  if (a) // ...

  if (a != 0) // ...

  &&    ||    !

  if (p && 1count) // ...

  if (a <= d)
      max = b;
  else
      max = a;

  max = (a<=b) ? b : a;

  switch (val) {
  case 1:
      f();
      break;
  case 2;
      g();
      break;
  default:
      h();
      break;
  }

  if (val == 1)
      f();
  else if (val == 2)
      g();
  else
      h();

  switch (val) {    // осторожно
  case 1:
      cout << "case 1\n";
  case 2;
      cout << "case 2\n";
  default:
      cout << "default: case не найден\n";
  }

  case 1
  case 2
  default: case не найден

  switch (val) {    // осторожно
  case 0:
      cout << "case 0\n";
  case1:
  case 1:
      cout << "case 1\n";
      return;
  case 2;
      cout << "case 2\n";
      goto case1;
  default:
      cout << "default: case не найден\n";
      return;
  }

  case 2
  case 1

  goto case 1;        // синтаксическая ошибка

3.3.2 Goto

C++ снабжен имеющим дурную репутацию оператором goto.

  goto идентификатор;
  идентификатор : оператор

  for (int i = 0; i

3.4 Комментарии и Выравнивание

Продуманное использование комментариев и согласованное использование отступов может сделать чтение и понимание программы намного более приятным. Существует несколько различных стилей согласованного использования отступов. Автор не видит никаких серьезных оснований предпочесть один другому (хотя как и у большинства, у меня есть свои предпочтения). Сказанное относится также и к стилю комментариев.
Неправильное использование комментариев может серьезно повлиять на удобочитаемость программы, Компилятор не понимает содержание комментария, поэтому он никаким способом не может убедиться в том, что комментарий
[1] осмыслен;
[2] описывает программу; и
[3] не устарел.
Непонятные, двусмысленные и просто неправильные комментарии содержатся в большинстве программ. Плохой комментарий может быть хуже, чем никакой.
Если что-то можно сформулировать средствами самого языка, следует это сделать, а не просто отметить в комментарии. Данное замечание относится к комментариям вроде:

  // переменная "v" должна быть инициализирована.
  // переменная "v" должна использоваться только функцией "f()".
  // вызвать функцию init() перед вызовом
  // любой другой функции в этом файле.
  // вызовите функцию очистки "cleanup()" в конце вашей
  программы.
  // не используйте функцию "wierd()".
  // функция "f()" получает два параметра.

3.5 Упражнения