Глава 1

Турне по C++

Прежде всего, давайте напишем программу, выводящую строку выдачи:

  #include

  main()
  {
      cout << "Hello, world\n";
  }

1.1.2 Компиляция

Откуда появились выходной поток cout и код, реализующий операцию вывода < Команда компиляции в C++ обычно называется CC. Она используется так же, как команда cc для программ на C; подробности вы можете найти в вашем руководстве. Предположим, что программа с "Hello, world" хранится в файле с именем hello.c, тогда вы можете ее скомпилировать и запустить примерно так ($ - системное приглашение):

  $ CC hello.c
  $ a.out
  Hello,world
  $

  $ CC hello.c -o hello
  $ hello
  Hello,world
  $

1.1.3 Ввод

Следующая (довольно многословная) программа предлагает вам ввести число дюймов. После того, как вы это сделаете, она напечатает соответствующее число сантиметров.

  #include

  main()
  {
      int inch = 0;         // inch - дюйм
      cout << "inches";
      cin >> inch;
      cout << inch;
      cout << " in = ";
      cout << inch*2.54;
      cout << " cm\n";
  }

  $ a.out
  inches=12
  12 in = 30.48 cm
  $

  cout << inch << " in = " << inch*2.54 << " cm\n";

1.2 Комментарии

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

  int inch;

  cout << inch << " in = " << inch*2.54 << " cm\n";

1.3.1 Основные Tипы

Основные типы, наиболее непосредственно отвечающие средствам аппаратного обеспечения, такие:

  char  short  int  long  float  double

  1 = sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)
  sizeof(float) <= sizeof(double)

  const float pi = 3.14;
  const char plus = '+';

  double d = 1;
  int i = 1;
  d = d + i;
  i = d + i;

1.3.2 Производные Типы

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

Самый обычный вид оператора - оператор выражение. Он состоит из выражения, за которым следует точка с запятой. Например:

  a = b*3+c;
  cout << "go go go";
  lseek(fd,0,2);

1.4.3 Пустой оператор

Простейшей формой оператора является пустой оператор:

;

Блок - это возможно пустой список операторов, заключенный в фигурные скобки:

  { a=b+2; b++; }

1.4.5 Операторы if

Программа в следующем примере осуществляет преобразование дюймов в сантиметры и сантиметров в дюймы; предполагается, что вы укажете единицы измерения вводимых данных, добавляя i для дюймов и c для сантиметров:

  #include

  main()
  {
      const float fac = 2.54;
      float x, in, cm;
      char ch = 0;

      cout << "введите длину: ";
      cin >> x >> ch;

      if (ch == 'i') {       // inch - дюймы
          in = x;
          cm = x*fac;
      }
      else if (ch == 'c')   //  cm - сантиметры
          in = x/fac;
          cm = x;
      }
      else
          in = cm = 0;

      cout << in << " in = " << cm << " cm\n";
  }

1.4.6 Операторы switch

Оператор switch производит сопоставление значения с множеством констант. Проверки в предыдущем примере можно записать так:

  switch (ch) {
  case 'i':
      in = x;
      cm = x*fac;
      break;
  case 'c':
      in = x/fac;
      cm = x;
      break;
  default:
      in = cm = 0;
      break;
  }

1.4.7 Оператор while

Рассмотрим копирование строки, когда заданы указатель p на ее первый символ и указатель q на целевую строку. По соглашению строка оканчивается символом с целым значением 0.

  while (p != 0) {
      *q = *p;        // скопировать символ
      q = q+1;
      p = p+1;
  }
  *q = 0;             // завершающий символ 0 скопирован не был

  while (*p)  *q++ = *p++;
  *q = 0;

  while (*q++ = *p++) ;

1.4.8 Оператор for

Рассмотрим копирование десяти элементов одного вектора в другой:

  for (int i=0; i<10; i++) q[i]=p[i];

  int i = 0;
  while (i<10) {
      q[i] = p[i];
      i++;
  }

  for (i=0; i<10; i++) q[i]=p[i];

1.4.9 Описания

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

  for (int i = 1; i

1.5 Функции

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

  extern float pow(float, int); //pow() определена в другом месте

  main()
  {
      for (int i=0; i<10; i++) cout << pow(2,i) << "\n";
  }

  float pow(float x, int n)
  {
   if (n < 0) error("извините, отрицательный показатель для pow()");

      switch (n) {
      case 0: return 1;
      case 1: return x;
      default:    return x*pow(x,n-1);
      }
  }

  overload pow;
  int pow(int, int);
  double pow(double, double);
  //...
  x=pow(2,10);
  y=pow(2.0,10.0);

  Описание

  overload pow;

  void swap(int* p, int* q)    // поменять местами
  {
      int t = *p;
      *p = *q;
      *q = t;
  }

1.6 Структура программы

Программа на C++ обычно состоит из большого числа исходных файлов, каждый из которых содержит описания типов, функций, переменных и констант. Чтобы имя можно было использовать в разных исходных файлах для ссылки на один и тот же объект, оно должно быть описано как внешнее. Например:

  extern double sqrt(double);
  extern instream cin;

  #include
  //...
  x = sqrt(4);

1.7 Классы

Давайте посмотрим, как мы могли бы определить тип потока вывода ostream. Чтобы упростить задачу, предположим, что для буферизации определен тип streambuf. Тип streambuf на самом деле определен в , где также находится и настоящее определение ostream. Пожалуйста, не испытывайте примеры, определяющие ostream в этом и последующих разделах; пока вы не сможете полностью избежать использования , компилятор будет возражать против переопределений.
Определение типа, определяемого пользователем (который в C++ называется class, т.е. класс), специфицирует данные, необходимые для представления объекта этого типа, и множество операций для работы с этими объектами. Определение имеет две части: закрытую (private) часть, содержащую информацию, которой может пользоваться только его разработчик, и открытую (public) часть, представляющую интерфейс типа с пользователем:

  class ostream {
      streambuf* buf;
      int state;
  public:
      void put(char*);
      void put(long);
      void put(double);
  }

  ostream my_out;

1.8 Перегрузка операций

Настоящий класс ostream определяет операцию <<, чтобы сделать удобным вывод нескольких объектов одним оператором. Давайте посмотрим, как это сделано.
Чтобы определить @, где @ - некоторая операция языка C++, для каждого определяемого пользователем типа вы определяете функцию с именем operator@, которая получает параметры соответствующего типа. Например:

  class ostream {
      //...
      ostream operator<<(char*);
  };

  ostream ostream::operator<<(char* p)
  {
      while (*p) buf.sputc(*p++);
      return *this;
  }

  &s1 == &my_out

1.9 Ссылки

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

  ostream& operator<<(ostream& s, complex z) {
      return s << "(" << z.real << "," << z.imag << ")";
  }

  class istream {
      //...
      int state;
  public:
      istream& operator>>(char&);
      istream& operator>>(char*);
      istream& operator>>(int&);
      istream& operator>>(long&);
      //...
  };

1.10 Конструкторы

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

  class ostream {
      //...
      ostream(streambuf*);
      ostream(int size, char* s);
  };

  ostream my_out(&some_stream_buffer);
  char xx[256];
  ostream xx_stream(256,xx);

1.11 Вектора

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

  class vector {
      int* v;
      int  sz;
  public:
          vector(int);      // конструктор
          ~vector();        // деструктор
      int size() { return sz; }
      void set_size(int);
      int& operator[](int);
      int& elem(int i) { return v[i]; }
  };

  vector::vector(int s)
  {
      if (s<=0) error("плохой размер вектора");
      sz = s;
      v = new int[s];
  }

  vector v1(100);
  vector v2(nelem*2-4);

  int& vector::operator[](int i)
  {
      if(i<0 || sz<=i) error("индекс выходит за границы");
      return v[i];
  }

  v1[x] = v2[y];

  vector::~vector()
  {
      delete v;
  }

1.12 Inline-подстановка

Если часто повторяется обращение к очень маленькой функции, то вы можете начать беспокоиться о стоимости вызова функции. Обращение к функции члену не дороже обращения к функции не члену с тем же числом параметров (надо помнить, что функция член всегда имеет хотя бы один параметр), и вызовы в функций в C++ примерно столь же эффективны, сколь и в любом языке. Однако для слишком маленьких функций может встать вопрос о накладных расходах на обращение. В этом случае можно рассмотреть возможность спецификации функции как inline-подставляемой. Если вы поступите таким образом, то компилятор сгенерирует для функции соответствующий код в месте ее вызова. Семантика вызова не изменяется. Если, например, size и elem inline-подставляемые, то

  vector s(100);
  //...
  i = s.size();
  x = elem(i-1);

  //...
  i = 100;
  x = s.v[i-1];

1.13 Производные классы

Теперь давайте определим вектор, для которого пользователь может задавать границы изменения индекса.

  class vec: public vector {
      int low, high;
  public:
      vec(int,int);
      int& elem(int);
      int& operator[](int);
  };

  :public vector

  int& vec::elem(int i)
  {
      return vector::elem(i-low);
  }

  vec::vec(int lb, int hb) : (hb-lb+1)
  {
      if (hb-lb<0) hb = lb;
      low = lb;
      high = hb;
  }

  #include

  void error(char* p)
  {
      cerr << p << "n\"; // cerr - выходной поток сообщений об
  ошибках
      exit(1);
  }

  void vector::set_size(int) { /* пустышка */ }

  int& vec::operator[](int i)
  {
      if (i

1.14 Еще об операциях

Другое направление развития - снабдить вектора операциями:

  class Vec : public vector {
  public:
      Vec(int s) : (s) {}
      Vec(Vec&);
      ~Vec() {}
      void operator=(Vec&);
      void operator*=(Vec&);
      void operator*=(int);
      //...
  };

  void Vec::operator=(Vec& a)
  {
      int s = size();
      if (s!=a.size()) error("плохой размер вектора для =");
      for (int i = 0; i

  void error(char* p) {
      cerr << p << "\n";
      exit(1);
  }

  void vector::set_size(int) { /*...*/ }

  int& vec::operator[](int i) { /*...*/ }

  main()
  {
      Vec a(10);
      Vec b(10);
      for (int i=0; i

1.15 Друзья (friends)

Функция operator+() не воздействует непосредственно на представление вектора. Действительно, она не может этого делать, поскольку не является членом. Однако иногда желательно дать функциям не членам возможность доступа к закрытой части класса. Например, если бы не было функции "доступа без проверки" vector::elem(), вам пришлось бы проверять индекс i на соответствие границам три раза за каждый проход цикла. Здесь мы избежали этой сложности, но она довольно типична, поэтому у класса есть механизм предоставления права доступа к своей закрытой части функциям не членам. Просто в описание класса помещается описание функции, перед которым стоит ключевое слово friend. Например, если имеется

  class Vec;  // Vec - имя класса

  class vector {
      friend Vec operator+(Vec, Vec);
      //...
  };

  Vec operator+(Vec a, Vec b)
  {
      int s = a.size();
      if (s != b.size()) error("плохой размер вектора для +");
      Vec& sum = *new Vec(s);
      int* sp = sum.v;
      int* ap = a.v;
      int* bp = b.v;
      while (s--) *sp++ = *ap++ + *bp++;
      return sum;
  }

1.16 Обобщенные Вектора

1.17 Полиморфные Вектора

У вас есть другая возможность - определить ваш векторный и другие вмещающие классы через указатели на объекты некоторого класса:

  class common {
      //...
  };
  class vector {
      common** v;
      //...
  public:
      cvector(int);
      common*& elem(int);
      common*& operator[](int);
      //...
  };

  class apple : public common { /*...*/ }
  class orange : public common { /*...*/ }
  class apple_vector : public cvector {
  public:

  cvector fruitbowl(100);
  //...
  apple aa;
  orange oo;
  //...
  fruitbowl[0] = &aa;
  fruitbowl[1] = &oo;
  }

  class apple_vector : public cvector {
  public:
      apple*& elem(int i)
          { return (apple*&) cvector::elem(i); }
      //...
  };

1.18 Виртуальные функции

Предположим, что мы пишем программу для изображения фигур на экране. Общие атрибуты фигуры представлены классом shape, а специальные атрибуты - специальными классами:

  class shape {
      point center;
      color col;
      //...
  public:
      void move(point to) { center=to; draw(); }
      point where() { return center; }
      virual void draw();
      virtual void rotate(int);
      //...
  };

  class circle: public shape {
      int radius;
  public:
      void draw();
      void rotatte(int i) {}
      //...
  };

  for (int i = 0; i