Турне по C++

Единственный способ изучать новый язык программирования - писать на нем программы.
- Брайэн Керниган

1.1 Введение

1.1.1 Вывод

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

  #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
  $

a.out -  это принимаемое  по умолчанию  имя исполняемого результата
компиляции. Если  вы  хотите  назвать  свою  программу,  вы  можете
сделать это с помощью опции -o:

  $ 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
  $

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

1.3 Типы и Описания

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

  int inch;

определяет, что  inch имеет  тип int, то есть,  inch является целой
переменной.

  Описание - это оператор, который вводит имя в программе. Описание
задает тип  этого имени.  Тип определяет   правильное использование
имени или выражения. Для целых определены такие операции, как +, -,
* и /. После того, как включен файл stream.h, объект типа int может
также быть вторым операндом <<, когда первый операнд ostream. 
  Тип объекта  определяет не только то, какие операции могут к нему
применяться, но и смысл этих операций. Например, оператор

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

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

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

  char  short  int  long  float  double

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

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

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

  Символ, заключенный  в  одинарные  кавычки,  является  символьной
константой.  Заметьте,  что  часто  константа,  определенная  таким
образом, не занимает память; просто там, где требуется, ее значение
может    использоваться     непосредственно.    Константа    должна
инициализироваться  при   описании.  Для  переменных  инициализация
необязательна,  но   настоятельно  рекомендуется.   Оснований   для
введения локальной переменной без ее инициализации очень немного.

  К любой  комбинации этих  типов могут  применяться арифметические
операции:

А также операции сравнения:

Заметьте, что  целое деление  дает целый результат: 7/2 есть 3. Над
целыми может выполняться операция % получения остатка: 7%2 равно 1.

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

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

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

Вот операции, создающие из основных типов новые типы:

  Например:

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

1.4.1 Выражения

В C++ имеется большое число операций, и они будут объясняться там, где (и если) это потребуется. Следует учесть, что операции

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

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

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

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

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

;

1.4.4 Блоки

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

  { 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 условие  должно  быть  заключено  в  круглые
скобки.  Условие   вычисляется,  и   если  его  значение  не  ноль,
выполняется  непосредственно   следующий  за   ним  оператор.   Это
повторяется до тех пор, пока вычисление условия не даст ноль.

  Этот пример  слишком пространен.  Можно использовать  операцию ++
для непосредственного указания увеличения, и проверка упростится:

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

где конструкция  *p++ означает: "взять символ, на который указывает
p, затем увеличить  p."

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

  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;

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

  Если функция  не возвращает  значения, то  ее следует описать как
void:

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

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

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

  extern double sqrt(double);
  extern instream cin;

Самый обычный  способ обеспечить  согласованность исходных файлов -
это  поместить   такие  описания   в  отдельные  файлы,  называемые
заголовочными (или  хэдер)  файлами,  а  затем  включить,  то  есть
скопировать, эти  заголовочные файлы  во все  файлы, где  нужны эти
описания. Например,  если описание  sqrt  хранится  в  заголовочном
файле для  стандартных математических  функций math.h,  и вы хотите
извлечь квадратный корень из 4, можно написать:

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

Описания после  метки public  задают интерфейс:  пользователь может
обращаться только  к трем  функциям put().  Описания  перед  меткой
public задают  представление объекта  класса ostream;  имена buf  и
state могут  использоваться только  функциями put(),  описанными  в
открытой части.

  class  определяет   тип,  а   не  объект  данных,  поэтому  чтобы
использовать ostream,  мы должны один такой объект описать (так же,
как мы описываем переменные типа int):

  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

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

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

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

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

 Функция size  возвращает число  элементов  вектора,  таким  образом
индексы должны  лежать в диапазоне 0 ... size()-1. Функция set_size
сделана для  изменения этого  размера, elem  обеспечивает доступ  к
элементам  без   проверки  индекса,  а  operator[]  дает  доступ  с
проверкой границ.

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

  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 -  это деструктор,  то  есть
функция, описанная  для того,  чтобы она  неявно вызывалась,  когда
объект класса  выходит из  области видимости.  Деструктор класса  C
имеет имя ~C. Если его определить как

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

Определение vec как

  :public vector

означает, в  первую очередь,  что vec  это vector. То есть, тип vec
имеет (наследует) все свойства типа vector дополнительно к тем, что
описаны специально  для него.  Говорят, что  класс vector  является
базовым классом  для vec,  а о vec говорится, что он производный от
vector.
 
 Класс vec  модифицирует класс  vector тем,  что  в  нем  задается
другой конструктор,  который требует  от пользователя указывать две
границы изменения  индекса, а  не длину, и имеются свои собственные
функции доступа  elem(int) и operator[](int). Функция elem() класса
vec легко выражается через elem() класса vector:

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

Операция разрешения  области видимости  :: используется  для  того,
чтобы не  было бесконечной  рекурсии обращения к vec::elem() из нее
самой. с помощью унарной операции :: можно ссылаться на нелокальные
имена. Было  бы разумно  описать vec::elem() как inline, поскольку,
скорее  всего,   эффективность   существенна,   но   необязательно,
неразумно и  невозможно написать  ее так, чтобы она непосредственно
использовала закрытый  член v  класса vector.  Фунции  производного
класса не имеют специального доступа к закрытым членам его базового
класса.

  Конструктор можно написать так:

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

Обратите внимание  на способ  определения конструктора производного
класса, Vec::Vec(),  когда он  передает свой  параметр конструктору
базового класса  vector::vector() и  больше не  делает ничего.  Это
полезная парадигма.  Операция присваивания  перегружена,  ее  можно
определить так:

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

Заметьте, что  поскольку в  таких векторах хранятся указатели, а не
сами объекты,  объект может  быть  "в"  нескольких  таких  векторах
одновременно.  Это   очень  полезное  свойство  подобных  вмещающих
классов, таких,  как вектора,  связанные списки,  множества и  т.д.
Кроме  того,  можно  присваивать  указатель  на  производный  класс
указателю  на   его  базовый   класс,  поэтому  можно  использовать
приведенный выше  cvector для  хранения указателей  на объекты всех
производных от common классов. Например:

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

Однако, точный  тип объекта,  вошедшего в  такой  вмещающий  класс,
больше компилятору  не известен.  Например, в предыдущем примере вы
знаете, что  элемент вектора  является common, но является он apple
или  orange?   Обычно   точный   тип   должен   в последствие   быть
восстановлен, чтобы  обеспечить правильное  использование  объекта.
Для этого  нужно или  в какой-то  форме хранить информацию о типе в
самом объекте,  или обеспечить, чтобы во вмещающий класс помещались
только объекты  данного типа. Последнее легко достигается с помощью
производного  класса.   Вы  можете,   например,  создать     вектор
указателей на apple:

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

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

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

Теперь, если shape_vec - вектор фигур, то можно написать:

  for (int i = 0; i