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

  #include



  main()

  {

      cout << "Hello, world\n";

  }

1.1.2 Компиляция

Откуда появились выходной поток cout и код, реализующий операцию вывода <<? Для получения выполняемого кода написанная на C++ программа должна быть скомпилирована; по своей сути процесс компиляции такой же, как и для С, и в нем участвует большая часть входящих в последний программ. Производится чтение и анализ текста программы, и если не обнаружены ошибки, то генерируется код. Затем программа проверяется на наличие имен и операций, которые использовались, но не были определены (в нашем случае это cout и <<). Если это возможно, то программа делается полной посредством дополнения недостающих определений из библиотеки (есть стандартные библиотеки, и пользователи могут создавать свои собственные). В нашем случае cout и << были описаны в stream.h, то есть, были указаны их типы, но не было дано никаких подробностей относительно их реализации. В стандартной библиотеке содержится спецификация пространства и инициализирующий код для cout и <<. На самом деле, в этой библиотеке содержится и много других вещей, часть из которых описана в stream.h, однако к скомпилированной версии добавляется только подмножество библиотеки, необходимое для того, чтобы сделать нашу программу полной.
Команда компиляции в 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

  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