овного типа,
 не может быть функцией-членом. ’ак, если мы прибавлЯем комплексную
 переменную aa к целому 2, то при подходЯщем описании функции-члена
 aa+2 можно интерпретировать как aa.operator+(2), но 2+aa так
 интерпретировать нельзЯ, поскольку не существует класса int, длЯ
 которого + определЯетсЯ как 2.operator+(aa). „аже если бы это было
 возможно, длЯ интерпретации aa+2 и 2+aa пришлось иметь дело с двумЯ
 разными функциЯми-членами. ќтот пример тривиально записываетсЯ
 с помощью функций, не ЯвлЯющихсЯ членами.
    Љаждое выражение проверЯетсЯ длЯ выЯвлениЯ неоднозначностей.
 …сли пользовательские операции задают возможную интерпретацию
 выражениЯ, оно проверЯетсЯ в соответствии с правилами $$R.13.2.

        7.3 Џользовательские операции преобразованиЯ типа

 ЋписаннаЯ во введении реализациЯ комплексного числа ЯвлЯетсЯ слишком
 ограниченной, чтобы удовлетворить кого-нибудь, и ее надо расширить.
 „елаетсЯ простым повторением описаний того же вида, что уже были
 применены:

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

          friend complex operator+(complex, complex);
          friend complex operator+(complex, double);
          friend complex operator+(double, complex);

          friend complex operator-(complex, double);
          friend complex operator-(complex, double);
          friend complex operator-(double, complex);
          complex operator-();  // унарный -

          friend complex operator*(complex, complex);
          friend complex operator*(complex, double);
          friend complex operator*(double, complex);

          // ...
        };

  €меЯ такое определение комплексного числа, можно писать:

       void f()
       {
         complex a(1,1), b(2,2), c(3,3), d(4,4), e(5,5);
         a = -b-c;
         b = c*2.0*c;
         c = (d+e)*a;
       }

  ‚се-таки утомительно, как мы это только что делали длЯ operator*()
  писать длЯ каждой комбинации complex и double свою функцию. Ѓолее
  того, разумные средства длЯ комплексной арифметики должны
  предоставлЯть десЯтки таких функций (посмотрите, например, как
  описан тип complex в &lt;complex.h>).

        7.3.1 Љонструкторы

  ‚место того, чтобы описывать несколько функций, можно описать
  конструктор, который из параметра double создает complex:

         class complex {
            // ...
            complex(double r) { re=r; im=0; }
         };

  ќтим определЯетсЯ как получить complex, если задан double. ќто
  традиционный способ расширениЯ вещественной прЯмой до комплексной
  плоскости.
      Љонструктор с единственным параметром не обЯзательно вызывать
  Явно:

         complex z1 = complex(23);
         complex z2 = 23;

  Ћбе переменные z1 и z2 будут инициализироватьсЯ вызовом complex(23).
      Љонструктор ЯвлЯетсЯ алгоритмом созданиЯ значениЯ заданного типа.
  …сли требуетсЯ значение некоторого типа и существует строЯщий его
  конструктор, параметром которого ЯвлЯетсЯ это значение, то тогда
  этот конструктор и будет использоватьсЯ. ’ак, класс complex можно
  было описать следующим образом:

         class complex {
            double re, im;
         public:
            complex(double r, double i =0) {  re=r; im=i; }

            friend complex operator+(complex, complex);
            friend complex operator*(complex, complex);

            complex operator+=(complex);
            complex operator*=(complex);

            // ...
         };

  ‚се операции над комплексными переменными и целыми константами
  с учетом этого описаниЯ становЯтсЯ законными. –елаЯ константа
  будет интерпретироватьсЯ как комплексное число с мнимой частью,
  равной нулю. ’ак, a=b*2 означает
         a = operator*(b, complex( double(2), double(0) ) )
  Ќовые версии операций таких, как + , имеет смысл определЯть только,
  если практика покажет, что повышение эффективности за счет отказа
  от преобразований типа стоит того. Ќапример, если выЯснитсЯ, что
  операциЯ умножениЯ комплексной переменной на вещественную
  константу ЯвлЯетсЯ критичной, то к множеству операций можно
  добавить operator*=(double):

        class complex {
          double re, im;
        public:
          complex(double r, double i =0) { re=r; im=i; }

          friend complex operator+(complex, complex);
          friend complex operator*(complex, complex);

          complex&amp; operator+=(complex);
          complex&amp; operator*=(complex);
          complex&amp; operator*=(double);

          // ...
        };

  Ћперации присваиваниЯ типа *= и += могут быть очень полезными
  длЯ работы с пользовательскими типами, поскольку обычно запись
  с ними короче, чем с их обычными "двойниками" * и + , а кроме того
  они могут повысить скорость выполнениЯ программы за счет
  исключениЯ временных переменных:

         inline complex&amp; complex::operator+=(complex a)
         {
            re += a.re;
            im += a.im;
            return *this;
         }

  Џри использовании этой функции не требуетсЯ временной переменной
  длЯ хранениЯ результата, и она достаточно проста, чтобы транслЯтор
  мог "идеально" произвести подстановку тела. ’акие простые операции
  как сложение комплексных тоже легко задать непосредственно:

         inline complex operator+(complex a, complex b)
         {
           return complex(a.re+b.re, a.im+b.im);
         }

  ‡десь в операторе return используетсЯ конструктор, что дает транслЯтору
  ценную подсказку на предмет оптимизации. Ќо длЯ более сложных
  типов и операций, например таких, как умножение матриц, результат
  нельзЯ задать как одно выражение, тогда операции * и + проще
  реализовать с помощью *= и += , и они будут легче поддаватьсЯ
  оптимизации:

         matrix&amp; matrix::operator*=(const matrix&amp; a)
         {
            // ...
            return *this;
         }

         matrix operator*(const matrix&amp; a, const matrix&amp; b)
         {
           matrix prod = a;
           prod *= b;
           return prod;
         }

  Ћтметим, что в определенной подобным образом операции не нужных
  никаких особых прав доступа к классу, к которому она применЯетсЯ,
  т.е. эта операциЯ не должна быть другом или членом этого класса.
     Џользовательское преобразование типа применЯетсЯ только в том
  случае, если оно единственное($$7.3.3).
    Џостроенный в результате Явного или неЯвного вызова конструктора,
  объект ЯвлЯетсЯ автоматическим, и уничтожаетсЯ при первой
  возможности,- как правило сразу после выполнениЯ оператора, в
  котором он был создан.

        7.3.2 Ћперации преобразованиЯ

  Љонструктор удобно использовать длЯ преобразованиЯ типа, но возможны
  нежелательные последствиЯ:
    [1] ЌеЯвные преобразованиЯ от пользовательского типа к основному
        невозможны (поскольку основные типы не ЯвлЯютсЯ классами).
    [2] ЌельзЯ задать преобразование из нового типа в старый, не
        изменЯЯ описаниЯ старого типа.
    [3] ЌельзЯ определить конструктор с одним параметром, не определив
        тем самым и преобразование типа.
     Џоследнее не ЯвлЯетсЯ большой проблемой, а первые две можно
  преодолеть, если определить операторную функцию преобразованиЯ
  длЯ исходного типа. ”ункциЯ-член X::operator T(), где T - имЯ
  типа, определЯет преобразование типа X в T. Ќапример, можно
  определить тип tiny (крошечный), значениЯ которого находЯтсЯ в
  диапазоне 0..63, и этот тип может в арифметических операциЯх практически
  свободно смешиватьсЯ с целыми:

          class tiny {
            char v;
            void assign(int i)
            { if (i>63) { error("выход из диапазона"); v=i&amp;~63;  }
              v=i;
            }
          public:
            tiny(int i) { assign(i) }
            tiny(const tiny&amp; t) { v = t.v; }
            tiny&amp; operator=(const tiny&amp; t)
               { v = t.v; return *this; }
            tiny&amp; operator=(int i) { assign(i); return *this; }
            operator int() { return v; }
          };

  Џопадание в диапазон проверЯетсЯ как при инициализации объекта
  tiny, так и в присваивании ему int. Ћдин объект tiny можно
  присвоить другому без контролЯ диапазона. „лЯ выполнениЯ обычных
  операций с целыми длЯ переменных типа tiny определЯетсЯ функциЯ
  tiny::operator int(), производЯщаЯ неЯвное преобразование типа
  из tiny в int. ’ам, где требуетсЯ int, а задана переменнаЯ типа
  tiny, используетсЯ преобразованное к int значение:

           void main()
           {
             tiny c1 = 2;
             tiny c2 = 62;
             tiny c3 = c2 -c1;  // c3 = 60
             tiny c4 = c3;      // контролЯ диапазона нет (он не нужен)
             int i = c1 + c2;   // i = 64
             c1 = c2 + 2 * c1;  // выход из диапазона: c1 = 0 (а не 66)
             c2 = c1 - i;       // выход из диапазона: c2 = 0
             c3 = c2;           // контролЯ диапазона нет (он не нужен)
           }


    Ѓолее полезным может оказатьсЯ вектор из объектов tiny, поскольку
 он позволЯет экономить памЯть. —тобы такой тип было удобно
 использовать, можно воспользоватьсЯ операцией индексации [].
    Џользовательские операции преобразованиЯ типа могут пригодитьсЯ
длЯ работы с типами, реализующими нестандартные представлениЯ чисел
(арифметика с основанием 100, арифметика чисел с фиксированной точкой,
представление в двоично-десЯтичной записи и т.д.). Џри этом обычно
приходитсЯ переопределЯть такие операции, как + и *.
    Ћсобенно полезными функции преобразованиЯ типа оказываютсЯ длЯ
 работы с такими структурами данных, длЯ которых чтение (реализованное
 как операциЯ преобразованиЯ) ЯвлЯетсЯ тривиальным, а присваивание и
 инициализациЯ существенно более сложные операции.
    ”ункции преобразованиЯ нужны длЯ типов istream и ostream, чтобы
 стали возможными, например, такие операторы:

         while (cin>>x) cout&lt;&lt;x;

 ЋперациЯ ввода cin>>x возвращает значение istream&amp;. Ћно неЯвно
 преобразуетсЯ в значение, показывающее состоЯние потока cin, которое
 затем проверЯетсЯ в операторе while (см. $$10.3.2). Ќо все-таки
 определЯть неЯвное преобразование типа, при котором можно потерЯть
 преобразуемое значение, как правило, плохое решение.
     ‚ообще, лучше экономно пользоватьсЯ операциЯми преобразованиЯ.
 €збыток таких операций может вызывать большое число неоднозначностей.
 ’ранслЯтор обнаруживает эти неоднозначности, но разрешить их может
 быть совсем непросто. ‚озможно вначале лучше длЯ преобразований
 использовать поименованные функции, например, X::intof(), и только
 после того, как такую функцию как следуют опробуют, и Явное
 преобразование типа будет сочтено неэлегантным решением, можно
 заменить операторной функцией преобразованиЯ X::operator int().

        7.3.3 Ќеоднозначности

 Џрисваивание или инициализациЯ объекта класса X ЯвлЯетсЯ законным,
 если присваиваемое значение имеет тип X, или если существует
 единственное преобразование его в значение типа X.
   ‚ некоторых случаЯх значение нужного типа строитсЯ с помощью
 повторных применений конструкторов или операций преобразованиЯ.
 ќто должно задаватьсЯ Явным образом, допустимо неЯвное пользовательское
 преобразование только одного уровнЯ вложенности. ‚ некоторых случаЯх
 существует несколько способов построениЯ значениЯ нужного типа, но
 это ЯвлЯетсЯ незаконным. Џриведем пример:

       class x { /* ... */ x(int); x(char*); };
       class y { /* ... */ y(int); };
       class z { /* ... */ z(x); };

       x f(x);
       y f(y);

       z g(z);

       void k1()
       {
         f(1);      // недопустимо, неоднозначность: f(x(1)) или f(y(1))
         f(x(1));
         f(y(1));
         g("asdf"); // недопустимо, g(z(x("asdf"))) не используетсЯ
       }

   Џользовательские преобразованиЯ типа рассматриваютсЯ только в том
случае, когда без них нельзЯ однозначно выбрать вызываемую функцию:

        class x { /* ... */ x(int); };

        void h(double);
        void h(x);

        void k2()
        {
          h(1);
        }

 ‚ызов h(1) можно интерпретировать либо как h(double(1)), либо как
 h(x(1)), поэтому в силу требованиЯ однозначности его можно счесть
 незаконным. Ќо поскольку в первой интерпретации используетсЯ
 только стандартное преобразование, то по правилам, указанным в $$4.6.6
 и $$R.13.2, выбираетсЯ оно.
     Џравила на преобразованиЯ типа не слишком просто сформулировать
 и реализовать, не обладают они и достаточной общностью. ђассмотрим
 требование единственности законного преобразованиЯ. Џроще всего
 разрешить транслЯтору применЯть любое преобразование, которое он
 сумеет найти. ’огда длЯ выЯснениЯ корректности выражениЯ не нужно
 рассматривать все существующие преобразованиЯ. Љ сожалению, в таком
 случае поведение программы будет зависеть от того, какое именно
 преобразование найдено. ‚ результате поведение программы будет
 зависеть от порЯдка описаний преобразований. Џоскольку часто эти
 описаниЯ разбросаны по разным исходным файлам (созданным, возможно,
 разными программистами), то результат программы будет зависеть
 в каком порЯдке эти файлы сливаютсЯ в программу. ‘ другой стороны,
 можно вообще запретить неЯвные преобразованиЯ, и это самое
 простое решение. Ќо результатом будет некачественный интерфейс,
 определЯемый пользователем, или взрывной рост перегруженных
 функций и операций, что мы и видели на примере класса complex
 из предыдущего раздела.
     Џри самом общем подходе учитываютсЯ все сведениЯ
 о типах и рассматриваютсЯ все существующие преобразованиЯ.
 Ќапример, с учетом приведенных описаний в присваивании aa=f(1)
 можно разобратьсЯ с вызовом f(1), поскольку тип aa задает
 единственное преобразование. …сли aa имеет тип x, то единственным
 преобразованием будет f(x(1)), поскольку только оно дает нужный
 длЯ левой части тип x. …сли aa имеет тип y, будет использоватьсЯ
 f(y(1)). Џри самом общем подходе удаетсЯ разобратьсЯ и с вызовом
 g("asdf"), поскольку g(z(x("asdf))) ЯвлЯетсЯ его единственной
 интерпретацией. ’рудность этого подхода в том, что требуетсЯ
 доскональный разбор всего выражениЯ, чтобы установить интерпретацию
 каждой операции и вызова функции. ‚ результате транслЯциЯ
 замедлЯетсЯ, вычисление выражениЯ может произойти странным образом
 и поЯвлЯютсЯ загадочные сообщениЯ об ошибках, когда транслЯтор
 учитывает определенные в библиотеках преобразованиЯ и т.д.
 ‚ результате транслЯтору приходитсЯ учитывать больше информации,
 чем известно самому программисту! ‚ыбран подход, при котором
 проверка ЯвлЯетсЯ строго восходЯщим процессом, когда в каждый
 момент рассматриваетсЯ только одна операциЯ с операндами, типы
 которых уже прошли проверку.
     ’ребование строго восходЯщего разбора выражениЯ предполагает,
 что тип возвращаемого значениЯ не учитываетсЯ при разрешении
 перегрузки:

          class quad {
             // ...
          public:
             quad(double);
             // ...
          };

          quad operator+(quad,quad);

          void f(double a1, double a2)
          {
            quad r1 = a1+a2;       // сложение с двойной точностью
            quad r2 = quad(a1)+a2; // вынуждает использовать
                                   // операции с типами quad
          }

 ‚ проектировании Языка делалсЯ расчет на строго восходЯщий разбор,
 поскольку он более понЯтный, а кроме того, не дело транслЯтора
 решать такие вопросы, какую точность длЯ сложениЯ желает
 программист.
     Ћднако, надо отметить, что если определились типы обеих частей
 в присваивании и инициализации, то длЯ их разрешениЯ используетсЯ
 они оба:

          class real {
             // ...
          public:
             operator double();
             operator int();
             // ...
          };

          void g(real a)
          {
            double d = a;  // d = a.double();
            int i = a;     // i = a.int();

            d = a;         // d = a.double();
            i = a;         // i = a.int();
          }

 ‚ этом примере выражениЯ все равно разбираютсЯ строго восходЯщим
 методом, когда в каждый момент рассматриваютсЯ только одна операциЯ
 и типы ее операндов.

        7.4 ‹итералы

 „лЯ классов нельзЯ определить литеральные значениЯ, подобному
 тому как 1.2 и 12e3 ЯвлЯютсЯ литералами типа double. Ћднако,
 длЯ интерпретации значений классов могут использоватьсЯ вместо
 функций-членов литералы основных типов. Ћбщим средством длЯ
 построениЯ таких значений служат конструкторы с единственным
 параметром. …сли конструктор достаточно простой и реализуетсЯ
 подстановкой, вполне разумно представлЯть его вызов как
 литерал. Ќапример, с учетом описаниЯ класса complex в &lt;complex.h>
 в выражении zz1*3+zz2*complex(1,2) произойдет два вызова функций,
 а не пЯть. „ве операции * приведут к вызову функции, а операциЯ
 + и вызовы конструктора длЯ построениЯ complex(3) и complex(1,2)
 будут реализованы подстановкой.

        7.5 Ѓольшие объекты

 Џри выполнении любой бинарной операции длЯ типа complex реализующей
 эту операцию функции будут передаватьсЯ как параметры копии обоих
 операндов. „ополнительные расходы, вызванные копированием двух
 значений типа double, заметны, хотЯ по всей видимости допустимы.
 Љ сожалению представление не всех классов ЯвлЯетсЯ столь удобно
 компактным. —тобы избежать избыточного копированиЯ, можно
 определЯть функции с параметрами типа ссылки:

           class matrix {
              double m[4][4];
           public:
              matrix();
              friend matrix operator+(const matrix&amp;, const matrix&amp;);
              friend matrix operator*(const matrix&amp;, const matrix&amp;);
           };

     ‘сылки позволЯют без излишнего копированиЯ использовать
 выражениЯ с обычными арифметическими операциЯми и длЯ больших
 объектов. “казатели длЯ этой цели использовать нельзЯ, т.к.
 невозможно переопределить интерпретацию операции, если она
 применЯетсЯ к указателю. Ћперацию плюс длЯ матриц можно определить
 так:

           matrix operator+(const matrix&amp; arg1, const&amp; arg2)
           {
              matrix sum;
              for (int i = 0; i&lt;4; i++)
                  for (int j=0; j&lt;4; j++)
                      sum.m[i] [j] = arg1.m[i][j] + arg2.m[i][j];
              return sum;
           }

 ‡десь в функции operator+() операнды выбираютсЯ по ссылке, а
 возвращаетсЯ само значение объекта. Ѓолее эффективным решением
 был бы возврат тоже ссылки:

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

 ќто допустимо, но возникает проблема с выделением памЯти. Џоскольку
 ссылка на результат операции будет передаватьсЯ как ссылка на
 возвращаемое функцией значение, оно не может быть автоматической
 переменной этой функции. Џоскольку операциЯ может использоватьсЯ
 неоднократно в одном выражении, результат не может быть и
 локальной статической переменной. Љак правило, результат будет
 записыватьсЯ в отведенный в свободной памЯти объект. Ћбычно
 бывает дешевле (по затратам на времЯ выполнениЯ и памЯть данных
 и команд) копировать результирующее значение, чем размещать его
 в свободной памЯти и затем в конечном счете освобождать выделенную
 памЯть. Љ тому же этот способ проще запрограммировать.

        7.6 Џрисваивание и инициализациЯ

 ђассмотрим простой строковый класс string:

             struct string {
                char* p;
                int size;  // размер вектора, на который указывает p

                string(int size) { p = new char[size=sz]; }
                ~string() { delete p; }
             };

 ‘трока - это структура данных, содержащаЯ указатель на вектор
 символов и размер этого вектора. ‚ектор создаетсЯ конструктором и
 удалЯетсЯ деструктором. Ќо как мы видели в $$5.5.1 здесь могут
 возникнуть проблемы:

             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 size) { p = new char[size=sz]; }
               ~string() { delete p; }
               string&amp; operator=(const string&amp;);
             };

             string&amp; string::operator=(const string&amp; a)
             {
               if (this !=&amp;a) {   // опасно, когда s=s
                  delete p;
                  p = new char[size=a.size];
                  strcpy(p,a.p);
               }
               return *this;
             }

      Џри таком определении string предыдущий пример пройдет как
 задумано. Ќо после небольшого изменениЯ в f() проблема возникает
 снова, но в ином обличии:

             void f()
             {
               string s1(10);
               string s2 = s1;  // инициализациЯ, а не присваивание
             }

 ’еперь только один объект типа string строитсЯ конструктором
 string::string(int), а уничтожатьсЯ будет две строки. „ело в
 том, что пользовательскаЯ операциЯ присваиваниЯ не применЯетсЯ
 к неинициализированному объекту. „остаточно взглЯнуть на функцию
 string::operator(), чтобы понЯть причину этого: указатель p
 будет тогда иметь неопределенное, по сути случайное значение.
 Љак правило, в операции присваиваниЯ предполагаетсЯ, что ее
 параметры проинициализированы. „лЯ инициализации типа той, что
 приведена в этом примере это не так по определению. ‘ледовательно,
 чтобы справитьсЯ с инициализацией нужна похожаЯ, но своЯ функциЯ:

             struct string {
               char* p;
               int size;   // размер вектора, на который указывает p

               string(int size) { p = new char[size=sz]; }
               ~string() { delete p; }
               string&amp; operator=(const string&amp;);
               string(const string&amp;);
             };

             string::string(const string&amp; a)
             {
                  p=new char[size=sz];
                  strcpy(p,a.p);
             }


       €нициализациЯ объекта типа X происходит с помощью конструктора
 X(const X&amp;). Њы не перестаем повторЯть, что присваивание и
 инициализациЯ ЯвлЯютсЯ разными операциЯми. Ћсобенно это важно в тех
 случаЯх, когда определен деструктор. …сли в классе X есть нетривиальный
 деструктор, например, производЯщий освобождение объекта в свободной
 памЯти, вероЯтнее всего, в этом классе потребуетсЯ полный набор
 функций, чтобы избежать копированиЯ объектов по членам:

             class X {
                // ...
                X(something);        // конструктор, создающий объект
                X(const X&amp;);         // конструктор копированиЯ
                operator=(const X&amp;); // присваивание:
                                     // удаление и копирование
                ~X();                // деструктор, удалЯющий объект
             };

       …сть еще два случаЯ, когда приходитсЯ копировать объект:
 передача параметра функции и возврат ею значениЯ. Џри передаче
 параметра неинициализированнаЯ переменнаЯ, т.е. формальный параметр
 инициализируетсЯ. ‘емантика этой операции идентична другим видам
 инициализации. ’оже происходит и при возврате функцией значениЯ,
 хотЯ этот случай не такой очевидный. ‚ обоих случаЯх используетсЯ
 конструктор копированиЯ:

            string g(string arg)
            {
              return arg;
            }

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

 Ћчевидно, после вызова g() значение s должно быть "asdf". Ќе трудно
 записать в параметр s копию значениЯ s, длЯ этого надо вызвать
 конструктор копированиЯ длЯ string. „лЯ получениЯ еще одной копии
 значениЯ s по выходе из g() нужен еще один вызов конструктора
 string(const string&amp;). Ќа этот раз инициализируетсЯ временнаЯ
 переменнаЯ, котораЯ затем присваиваетсЯ s. „лЯ оптимизации одну,
 но не обе, из подобных операций копированиЯ можно убрать. …стественно,
 временные переменные, используемые длЯ таких целей, уничтожаютсЯ
 надлежащим образом деструктором string::~string() (см. $$R.12.2).
     …сли в классе X операциЯ присваиваниЯ X::operator=(const X&amp;)
 и конструктор копированиЯ X::X(const X&amp;) Явно не заданы программистом,
 недостающие операции будут созданы транслЯтором. ќти созданные
 функции будут копировать по членам длЯ всех членов класса X. …сли
 члены принимают простые значениЯ, как в случае комплексных чисел,
 это, то, что нужно, и созданные функции превратЯтсЯ в простое и
 оптимальное поразрЯдное копирование. …сли длЯ самих членов
 определены пользовательские операции копированиЯ, они и будут
 вызыватьсЯ соответствующим образом:

           class Record {
             string name, address, profession;
             // ...
           };

           void f(Record&amp; r1)
           {
             Record r2 = r1;
           }

  ‡десь длЯ копированиЯ каждого члена типа string из объекта r1
  будет вызыватьсЯ string::operator=(const string&amp;). ‚ нашем первом
  и неполноценном варианте строковый класс имеет член-указатель
  и деструктор. Џоэтому стандартное копирование по членам длЯ
  него почти навернЯка неверно. ’ранслЯтор может предупреждать
  о таких ситуациЯх.


        7.7 €ндексациЯ

 ЋператорнаЯ функциЯ operator[] задает длЯ объектов классов
 интерпретацию индексации. ‚торой параметр этой функций (индекс) может
 иметь произвольный тип. ќто позволЯет, например, определЯть
 ассоциативные массивы. ‚ качестве примера можно переписать
 определение из $$2.3.10, где ассоциативный массив использовалсЯ
 в небольшой программе, подсчитывающей число вхождений слов в файле.
 ’ам длЯ этого использовалась функциЯ. Њы определим настоЯщий тип
 ассоциативного массива:

           class assoc {
              struct pair {
                 char* name;
                 int val;
              };

              pair* vec;
              int max;
              int free;

              assoc(const assoc&amp;);            // предотвращает копирование
              assoc&amp; operator=(const assoc&amp;); // предотвращает копирование
           public:
              assoc(int);
              int&amp; operator[](const char*);
              void print_all();
            };

 ‚ объекте assoc хранитсЯ вектор из структур pair размером max.
 ‚ переменной free хранитсЯ индекс первого свободного элемента
 вектора.
     —тобы предотвратить копирование объектов assoc, конструктор
 копированиЯ и операциЯ присваиваниЯ описаны как частные. Љонструктор
 выглЯдит так:

            assoc::assoc(int s)
            {
              max = (s&lt;16) ? 16 : s;
              free = 0;
              vec = new pair[max];
            }

 ‚ реализации используетсЯ все тот же неэффективный алгоритм поиска,
 что и в $$2.3.10. Ќо теперь, если вектор переполнЯетсЯ, объект
 assoc увеличиваетсЯ:

            #include &lt;string.h>

            int&amp; assoc::operator[](const char* p)
            /*
              работает с множеством пар (структур pair):
              проводит поиск p, возвращает ссылку на
              целое значение из найденной пары,
              создает новую пару, если p не найдено
            */
            {
              register pair* pp;

              for (pp=&amp;vec[free-1]; vec&lt;=pp; pp-- )
                  if (strcmp(p,pp->name) == 0) return pp->val;
              if (free == max) { //переполнение: вектор увеличиваетсЯ
                 pair* nvec = new pair[max*2];
                 for (int i=0; i&lt;max; i++) nvec[i] = vec[i];
                 delete vec;
                 vec = nvec;
                 max = 2*max;
              }

              pp = &amp;vec[free++];
              pp->name = new char[strlen(p)+1];
              strcpy(pp->name,p);
              pp->val = 0;    // начальное значение = 0
              return pp->val;
            }

 Џоскольку представление объекта assoc скрыто от пользователЯ, нужно
 иметь возможность напечатать его каким-то образом. ‚ следующем разделе
 будет показано как определить настоЯщий итератор длЯ такого объекта.
 ‡десь же мы ограничимсЯ простой функцией печати:

            void assoc::print_all()
            {
              for (int i = 0; i&lt;free; i++)
                  cout &lt;&lt; vec[i].name &lt;&lt; ": " &lt;&lt; vec[i].val &lt;&lt; '\n';
            }

 Ќаконец, можно написать тривиальную программу:

            main() // подсчет числа вхождений во входной
                   // поток каждого слова
            {
              const MAX = 256;  // больше длины самого длинного слова
              char buf[MAX];
              assoc vec(512);
              while (cin>>buf) vec[buf]++;
              vec.print_all();
            }

 Ћпытные программисты могут заметить, что второй комментарий можно
 легко опровергнуть. ђешить возникающую здесь проблему предлагаетсЯ
 в упражнении $$7.14 [20]. „альнейшее развитие понЯтие ассоциативного
 массива получит в $$8.8.
     ”ункциЯ operator[]() должна быть членом класса. Ћтсюда следует,
 что эквивалентность x[y] == y[x] может не выполнЯтьсЯ, если
 x объект класса. Ћбычные отношениЯ эквивалентности, справедливые
 длЯ операций со встроенными типами, могут не выполнЯтьсЯ длЯ
 пользовательских типов ($$7.2.2, см. также $$7.9).

        7.8 ‚ызов функции

 ‚ызов функции, т.е. конструкцию выражение(список-выражений), можно
 рассматривать как бинарную операцию, в которой выражение ЯвлЯетсЯ
 левым операндом, а список-выражений - правым. Ћперацию вызова
 можно перегружать как и другие операции. ‚ функции operator()()
 список фактических параметров вычислЯетсЯ и проверЯетсЯ по типам
 согласно обычным правилам передачи параметров. Џерегрузка операции
 вызова имеет смысл прежде всего длЯ типов, с которыми возможна
 только одна операциЯ, а также длЯ тех типов, одна из операций над
 которыми имеет настолько важное значение, что все остальные в
 большинстве случаев можно не учитывать.
      Њы не дали определениЯ итератора длЯ ассоциативного массива
 типа assoc. „лЯ этой цели можно определить специальный класс
 assoc_iterator, задача которого выдавать элементы из assoc в некотором
 порЯдке. ‚ итераторе необходимо иметь доступ к данным, хранимым
 в assoc, поэтому он должен быть описан как friend:

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

  €тератор можно определить так:

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

Њассив assoc объекта assoc_iterator нужно инициализировать, и при каждом
обращении к нему с помощью операторной функции () будет возвращатьсЯ
указатель на новую пару (структура 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(vec) )
                  cout &lt;&lt; p->name &lt;&lt; ": " &lt;&lt; p->val &lt;&lt; '\n';
            }

      €тератор подобного вида имеет преимущество перед набором
функций, решающим ту же задачу: итератор может иметь собственные
частные данные, в которых можно хранить информацию о ходе итерации.
Ћбычно важно и то, что можно одновременно запустить сразу несколько
итераторов одного типа.
      Љонечно, использование объектов длЯ представлениЯ итераторов
непосредственно никак не свЯзано с перегрузкой операций. Ћдни
предпочитают использовать тип итератора с такими операциЯми, как
first(), next() и last(), другим больше нравитсЯ перегрузка операции
++ , котораЯ позволЯет получить итератор, используемый как указатель
(см. $$8.8). Љроме того, операторнаЯ функциЯ operator() активно
используетсЯ длЯ выделениЯ подстрок и индексации многомерных массивов.
      ”ункциЯ operator() должна быть функцией-членом.

        7.9 Љосвенное обращение

Ћперацию косвенного обращениЯ к члену -> можно определить как унарную
постфиксную операцию. ќто значит, если есть класс

           class Ptr {
             // ...
             X* operator->();
           };

объекты класса Ptr могут использоватьсЯ длЯ доступа к членам класса
X также, как длЯ этой цели используютсЯ указатели:

          void f(Ptr p)
          {
            p->m = 7;  // (p.operator->())->m = 7
          }

Џревращение объекта p в указатель p.operator->() никак не зависит от
члена m, на который он указывает. €менно по этой причине operator->()
ЯвлЯетсЯ унарной постфиксной операцией. Ћднако, мы не вводим новых
синтаксических обозначений, так что имЯ члена по-прежнему должно
идти после -> :

           void g(Ptr p)
           {
              X* q1 = p->;  // синтаксическаЯ ошибка
              X* q2 = p.operator->(); // нормально
           }

     Џерегрузка операции -> прежде всего используетсЯ длЯ созданиЯ
"хитрых указателей", т.е. объектов, которые помимо использованиЯ как
указатели позволЯют проводить некоторые операции при каждом обращении
к указуемому объекту с их помощью. Ќапример, можно определить класс
RecPtr длЯ организации доступа к объектам класса Rec, хранимым на
диске. Џараметром конструктора RecPtr ЯвлЯетсЯ имЯ, которое будет
использоватьсЯ длЯ поиска объекта на диске. Џри обращении к объекту
с помощью функции RecPtr::operator->() он переписываетсЯ в основную
памЯть, а в конце работы деструктор RecPtr записывает измененный
объект обратно на диск.

            class RecPtr {
               Rec* in_core_address;
               const char* identifier;
               // ...
            public:
               RecPtr(const char* p)
               : identifier(p) { in_core_address = 0; }
               ~RecPtr()
                  { write_to_disc(in_core_address,identifier); }
               Rec* operator->();
            };

            Rec* RecPtr::operator->()
            {
              if (in_core_address == 0)
                  in_core_address = read_from_disc(identifier);
              return in_core_address;
            }

€спользовать это можно так:

            main(int argc, const char* argv)
            {
              for (int i = argc; i; i--) {
                  RecPtr p(argv[i]);
                  p->update();
              }
            }

Ќа самом деле, тип RecPtr должен определЯтьсЯ как шаблон типа
(см. $$8), а тип структуры Record будет его параметром. Љроме
того, настоЯщаЯ программа будет содержать обработку ошибок и
взаимодействие с диском будет организовано не столь примитивно.
      „лЯ обычных указателей операциЯ -> эквивалентна операциЯм,
использующим * и []. ’ак, если описано

            Y* p;

то выполнЯетсЯ соотношение

            p->m == (*p).m == p[0].m

Љак всегда, длЯ определенных пользователем операций такие соотношениЯ
не гарантируютсЯ. ’ам, где все-таки такаЯ эквивалентность требуетсЯ,
ее можно обеспечить:

            class X {
              Y* p;
            public:
              Y* operator->() { return p; }
              Y&amp; operator*() { return *p; }
              Y&amp; operator[](int i) { return p[i]; }
            };

    …сли в вашем классе определено более одной подобной операции,
разумно будет обеспечить эквивалентность, точно так же, как разумно
предусмотреть длЯ простой переменной x некоторого класса, в котором
есть операции ++, += = и +, чтобы операции ++x и x+=1 были
эквивалентны x=x+1.
   Џерегрузка -> как и перегрузка [] может играть важную роль длЯ
целого класса настоЯщих программ, а не ЯвлЯетсЯ просто экспериментом
ради любопытства. „ело в том, что в программировании понЯтие
косвенности ЯвлЯетсЯ ключевым, а перегрузка -> дает Ясный, прЯмой
и эффективный способ представлениЯ этого понЯтиЯ в программе.
…сть другаЯ точка зрениЯ на операцию ->, как на средство задать
в ‘++ ограниченный, но полезный вариант понЯтиЯ делегированиЯ
(см. $$12.2.8 и 13.9).

        7.10 €нкремент и декремент

…сли мы додумались до "хитрых указателей", то логично попробовать
переопределить операции инкремента ++ и декремента -- , чтобы
получить длЯ классов те возможности, которые эти операции дают длЯ
встроенных типов. ’акаЯ задача особенно естественна и необходима, если
ставитсЯ цель заменить тип обычных указателей на тип "хитрых указателей",
длЯ которого семантика остаетсЯ прежней, но поЯвлЯютсЯ некоторые
действиЯ динамического контролЯ. Џусть есть программа с распространенной
ошибкой:

           void f1(T a)   // традиционное использование
           {
             T v[200];
             T* p = &amp;v[10];
             p--;
             *p = a;   // Џриехали: `p' настроен вне массива,
                       // и это не обнаружено
             ++p;
             *p = a;   // нормально
           }

…стественно желание заменить указатель p на объект класса
CheckedPtrToT, по которому косвенное обращение возможно только
при условии, что он действительно указывает на объект. ЏрименЯть
инкремент и декремент к такому указателю будет можно только в том
случае, что указатель настроен на объект в границах массива и
в результате этих операций получитсЯ объект в границах того же
массива:

           class CheckedPtrToT {
              // ...
           };

           void f2(T a)  // вариант с контролем
           {
             T v[200];
             CheckedPtrToT p(&amp;v[0],v,200);
             p--;
             *p = a;  // динамическаЯ ошибка:
                      // `p' вышел за границы массива
             ++p;
             *p = a;  // нормально
           }

€нкремент и декремент ЯвлЯютсЯ единственными операциЯми в ‘++,
которые можно использовать как постфиксные и префиксные операции.
‘ледовательно, в определении класса CheckedPtrToT мы должны
предусмотреть отдельные функции длЯ префиксных и постфиксных операций
инкремента и декремента:

           class CheckedPtrToT {
             T* p;
             T* array;
             int size;
           public:
                  // начальное значение `p'
                  // свЯзываем с массивом `a' размера `s'
               CheckedPtrToT(T* p, T* a, int s);
                  // начальное значение `p'
                  // свЯзываем с одиночным объектом
               CheckedPtrToT(T* p);

               T* operator++();     // префикснаЯ
               T* operator++(int);  // постфикснаЯ

               T* operator--();     // префикснаЯ
               T* operator--(int);  // постфикснаЯ

               T&amp; operator*();      // префикснаЯ
            };

Џараметр типа int служит указанием, что функциЯ будет вызыватьсЯ
длЯ постфиксной операции. Ќа самом деле этот параметр ЯвлЯетсЯ
искусственным и никогда не используетсЯ, а служит только длЯ различиЯ
постфиксной и префиксной операции. —тобы запомнить, какаЯ версиЯ
функции operator++ используетсЯ как префикснаЯ операциЯ, достаточно
помнить, что префиксной ЯвлЯетсЯ версиЯ без искусственного параметра,
что верно и длЯ всех других унарных арифметических и логических
операций. €скусственный параметр используетсЯ только длЯ "особых"
постфиксных операций ++ и --.
    ‘ помощью класса CheckedPtrToT пример можно записать так:

             void f3(T a)  // вариант с контролем
             {
               T v[200];
               CheckedPtrToT p(&amp;v[0],v,200);
               p.operator--(1);
               p.operator*() = a; // динамическаЯ ошибка:
                                  // `p' вышел за границы массива
               p.operator++();
               p.operator*() = a; // нормально
             }

‚ упражнении $$7.14 [19] предлагаетсЯ завершить определение класса
CheckedPtrToT, а другим упражнением ($$9.10[2]) ЯвлЯетсЯ
преобразование его в шаблон типа, в котором длЯ сообщений о
динамических ошибках используютсЯ особые ситуации. Џримеры использованиЯ
операций ++ и -- длЯ итераций можно найти в $$8.8.

        7.11 ‘троковый класс

 ’еперь можно привести более осмысленный вариант класса string.
 ‚ нем подсчитываетсЯ число ссылок на строку, чтобы минимизировать
 копирование, и используютсЯ как константы стандартные строки C++.

            #include &lt;iostream.h>
            #include &lt;string.h>

            class string {
               struct srep {
                 char* s;       // указатель на строку
                 int n;         // счетчик числа сс