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

Здесь водятся Драконы! - старинная карта

6.1 Введение

Часто программы работают с объектами, которые являются конкретными представлениями абстрактных понятий. Например, тип данных int в C++ вместе с операциями +, -, *, / и т.д. предоставляет реализацию (ограниченную) математического понятия целых чисел. Такие понятия обычно включают в себя множество операций, которые кратко, удобно и привычно представляют основные действия над объектами. К сожалению, язык программирования может непосредственно поддерживать лишь очень малое число таких понятий. Например, такие понятия, как комплексная арифметика, матричная алгебра, логические сигналы и строки не получили прямой поддержки в C++. Классы дают средство спецификации в C++ представления неэлементарных объектов вместе с множеством действий, которые могут над этими объектами выполняться. Иногда определение того, как действуют операции на объекты классов, позволяет программисту обеспечить более общепринятую и удобную запись для манипуляции объектами классов, чем та, которую можно достичь используя лишь основную функциональную запись. Например:

  class complex {
      double re, im;
  public:
      complex(double r, double i) { re=r; im=i; }
      friend complex operator+(complex, complex);
      friend complex operator*(complex, complex);
  };

определяет простую реализацию понятия комплексного числа, в которой число представляется парой чисел с плавающей точкой двойной точности, работа с которыми осуществляется посредством операций + и * (и только). Программист задает смысл операций + и * с помощью определения функций с именами operator+ и operator*. Если, например, даны b и c типа complex, то b+c означает (по определению) operator+(b,c). Теперь есть возможность приблизить общепринятую интерпретацию комплексных выражений. Например:

  void f()
  {
      complex a = complex(1, 3.1);
      complex b = complex(1.2, 2);
      complex c = b;
      a = b+c;
      b = b+c*a;
      c = a*b+complex(1,2);
  }

6.2 Функции Операции

Можно описывать функции, определяющие значения следующих операций:

  +   -   *   /   %   ^   &   |   ~   !
  =   <>   +=  -=  *=  /=  %=  ^=  &=
  |=  <<>>  >>= <<= !="<=">=  &&
  ||  ++  --  []  ()  new delete

  class matrix {
      // ...
      friend matrix& operator+(matrix&, matrix&);
      friend matrix& operator*(matrix&, matrix&);
  };

6.6 Присваивание и Инициализация

Рассмотрим очень простой класс строк string:

  struct string {
      char* p;
      int size;    // размер вектора, на который указывает p
      string(int sz) { p = new char[size=sz]; }
      ~string() { delete p; }
  };

  Строка -  это структура  данных, состоящая  из вектора символов и
длины этого  вектора. Вектор создается конструктором и уничтожается
деструктором. Однако,  как показано  в #5.10,  это может привести к
неприятностям. Например:

  void f()
  {
      string s1(10);
      string s2(20);
      s1 = s2;
  }

будет размещать  два вектора  символов, а  присваивание s1=s2 будет
портить указатель на один из них и дублировать другой. На выходе из
f() для s1 и s2 будет вызываться деструктор и уничтожать один и тот
же вектор  с непредсказуемо  разрушительными последствиями. Решение
этой  проблемы   состоит  в   том,  чтобы  соответствующим  образом
определить присваивание объектов типа string:

  struct string {
      char* p;
      int size;    // размер вектора, на который указывает p
      string(int sz) { p = new char[size=sz]; }
      ~string() { delete p; }
      void operator=(string&)
  };
  void string::operator=(string& a)
  {
      if (this == &a) return;      // остерегаться s=s;
      delete p;
      p=new char[size=a.size];
      strcpy(p,a.p);
  }

  Это определение  string гарантирует, и что предыдущий пример будет
работать  как   предполагалось.  Однако   небольшое  изменение  f()
приведет к появлению той же проблемы в новом облике:

  void f()
  {
      string s1(10);
      s2 = s1;
  }

Теперь  создается   только  одна  строка,  а  уничтожается  две.  К
неинициализированному объекту  определенная пользователем операция
присваивания не  применяется. Беглый  взгляд на string::operator=()
объясняет, почему  было неразумно  так делать:  указатель  p  будет
содержать неопределенное  и совершенно  случайное  значение.  Часто
операция  присваивания   полагается  на   то,  что   ее   аргументы
инициализированы. Для  такой инициализации,  как здесь, это не так
по определению. Следовательно, нужно определить похожую, но другую,
функцию, чтобы обрабатывать инициализацию:

  struct string {
      char* p;
      int size;    // размер вектора, на который указывает p
      string(int sz) { p = new char[size=sz]; }
      ~string() { delete p; }
      void operator=(string&)
      string(string&);
  };
  void string::string(string& a)
  {
      p=new char[size=a.size];
      strcpy(p,a.p);
  }

  Для типа  X инициализацию тем же типом X обрабатывает конструктор
X(X&).  Нельзя   не  подчеркнуть   еще  раз,   что  присваивание  и
инициализация -  разные  действия.  Это  особенно  существенно  при
описании деструктора.  Если класс  X имеет конструктор, выполняющий
нетривиальную работу  вроде освобождения  памяти, то  скорее  всего
потребуется  полный  комплект  функций,  чтобы  полностью  избежать
побитового копирования объектов:

  class X {
      // ...
      X(something);  // конструктор: создает объект
      X(&X);         // конструктор: копирует в инициализации
      operator=(X&); // присваивание: чистит и копирует
      ~X();          // деструктор: чистит
  };

  Есть еще  два  случая,  когда  объект  копируется:  как  параметр
функции и  как возвращаемое  значение. Когда  передается  параметр,
инициализируется  неинициализированная   до  этого   переменная   -
формальный параметр.  Семантика идентична  семантике инициализации.
То же  самое происходит  при возврате  из функции,  хотя это  менее
очевидно. В обоих случаях будет применен X(X&), если он определен:

  string g(string arg)
  {
      return arg;
  }
  main()
  {
      string s = "asdf";
      s = g(s);
  }

6.7 Индексирование

6.8 Вызов Функции

Вызов функции, то есть запись выражение(список_выражений), можно проинтерпретировать как бинарную операцию, и операцию вызова можно перегружать так же, как и другие операции. Список параметров функции operator() вычисляется и проверяется в соответствие с обычными правилами передачи параметров. Перегружающая функция может оказаться полезной главным образом для определения типов с единственной операцией и для типов, у которых одна операция настолько преобладает, что другие в большинстве ситуаций можно не принимать во внимание.
Для типа ассоциативного массива assoc мы не определили итератор. Это можно сделать, определив класс assoc_iterator, работа которого состоит в том, чтобы в определенном порядке поставлять элементы из assoc. Итератору нужен доступ к данным, которые хранятся в assoc, поэтому он сделан другом:

  class assoc {
  friend class assoc_iterator;
      pair* vec;
      int max;
      int free;
  public:
      assoc(int);
      int& operator[](char*);
  };

Итератор определяется как

  class assoc_iterator{
      assoc* cs;  // текущий массив assoc
      int i;      // текущий индекс
  public:
      assoc_iterator(assoc& s) { cs = &s; i = 0; }
      pair* operator()()
          { return (ifree)? &cs->vec[i++] : 0; }
  };

Надо инициализировать  assoc_iterator для массива assoc, после чего
он будет  возвращать указатель на новую pair из этого массива всякий
раз, когда  его будут  активизировать операцией  (). По  достижении
конца массива он возвращает 0:

  main()    // считает вхождения каждого слова во вводе
  {
      const MAX = 256;  // больше самого большого слова
      char buf[MAX];
      assoc vec(512);
      while (cin>>buf) vec[buf]++;
      assoc_iterator next(vec);
      pair* p;
      while ( p = next() )
          cout << p->name << ": " << p->val << "\n"; } 

6.9 Класс Строка

Вот довольно реалистичный пример класса string. В нем производится учет ссылок на строку с целью минимизировать копирование и в качестве констант применяются стандартные символьные строки C++.

  #include
  #include
  class string {
      struct srep {
          char* s;           // указатель на данные
          int   n;           // счетчик ссылок
  };
      srep *p;
  public:
      string(char *);        // string x = "abc"
      string();              // string x;
      string(string &);      // string x = string ...
      string& operator=(char *);
      string& operator=(string &);
      ~string();
      char& operator[](int i);
      friend ostream& operator<<(ostream&, string&); friend istream& operator>>(istream&, string&);
      friend int operator==(string& x, char* s)
          {return strcmp(x.p->s, s) == 0; }
      friend int operator==(string& x, string& y)
          {return strcmp(x.p->s, y.p->s) == 0; }
      friend int operator!=(string& x, char* s)
          {return strcmp(x.p->s, s) != 0; }
      friend int operator!=(string& x, string& y)
          {return strcmp(x.p->s, y.p->s) != 0; }
  };

Конструкторы и деструкторы просты (как обычно):

  string::string()
  {
      p = new srep;
      p->s = 0;
      p->n = 1;
  }
  string::string(char* s)
  {
      p = new srep;
      p->s = new char[ strlen(s)+1 ];
      strcpy(p->s, s);
      p->n = 1;
  }
  string::string(string& x)
  {
      x.p->n++;
      p = x.p;
  }
  string::~string()
  {
      if (--p->n == 0) {
          delete p->s;
          delete p;
      }
  }

  Как обычно,  операции присваивания  очень похожи на конструкторы.
Они должны обрабатывать очистку своего первого (левого) операнда:

  string& string::operator=(char* s)
  {
      if (p->n > 1) {    // разъединить себя
          p-n--;
          p = new srep;
      }
      else if (p->n == 1)
          delete p->s;
      p->s = new char[ strlen(s)+1 ];
      strcpy(p->s, s);
      p->n = 1;
      return *this;
  }

  Благоразумно обеспечить,  чтобы присваивание  объекта самому себе
работало правильно:

  string& string::operator=(string& x)
  {
      x.p->n++;
      if (--p->n == 0) {
          delete p->s;
          delete p;
      }
      p = x.p;
      return *this;
  }

6.10 Друзья и Члены

6.11 Предостережение

6.12 Упражнения