/ X(int); };
         class Y { /* ... */ Y(X); };
         Y a = 1;        // недопустимо: преобразование Y(X(1))
                         // не применЯетсЯ

        R.12.3.2 ”ункции преобразованиЯ

”ункциЯ-член класса X, имЯ которой имеет вид,

         имЯ-функции-преобразованиЯ:
             operator имЯ-типа-преобразованиЯ

         имЯ-типа-преобразованиЯ:
             список-спецификаций-типа opt операциЯ-ptr opt

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

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

          void f(X a)
          {
            int i = int(a);
            i = (int)a;
            i = a;
           }

‡десь во всех трех операторах присваиваемое значение будет
преобразовыватьсЯ с помощью функции X::operator int(). Џользовательские
преобразованиЯ не ограничиваютсЯ только использованием в присваивании
и инициализации, например:

           void g(X a, X b)
           {
             int i = (a) ? 1+a : 0;
             int j = (a&amp;&amp;b) ? a+b : i;
             if (a) { // ...
             }
           }

   Ћперации преобразованиЯ наследуютсЯ. ”ункции преобразованиЯ
могут быть виртуальными.
   Љ данному значению неЯвно применЯетсЯ не более одного
пользовательского преобразованиЯ (с помощью конструктора или функции
преобразованиЯ), например:

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

     class Y {
       // ...
     public:
       operator X();
     };

     Y a;
     int b = a;     // недопустимо: преобразование
                    // a.operator X().operator int() не применЯетсЯ
     int c = X(a);  // нормально: a.operator X().operator int()

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

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

           class Y : public X {
           public:
             // ...
             operator void*();
           };

           void f(Y&amp; a)
           {
             if (a) {  // ошибка: неоднозначность
             }
           }

        R.12.4 „еструкторы

„еструктором называетсЯ функциЯ-член класса cl с именем ~cl, она
используетсЯ длЯ уничтожениЯ значений типа cl непосредственно перед
уничтожением объекта, содержащего их. „еструктор не имеет формальных
параметров и длЯ него нельзЯ задать тип возвращаемого значениЯ
(даже void). ЌельзЯ применЯть операцию взЯтиЯ адреса длЯ деструктора.
Њожно вызывать деструктор длЯ объектов со спецификацией const или
volatile, но сам деструктор нельзЯ описывать с этими спецификациЯми
($$R.9.3.1). „еструктор не может быть и статическим.
    „еструкторы не наследуютсЯ. …сли базовый класс или член имеют
деструктор, а сам производный класс - нет, то создаетсЯ стандартный
деструктор, который вызывает деструкторы базовых классов и членов
производного класса. ’акие созданные деструкторы имеют спецификацию
public.
    ’ело деструктора выполнЯетсЯ прежде деструкторов длЯ объектов,
ЯвлЯющихсЯ членами. „еструкторы длЯ нестатических объектов, ЯвлЯющихсЯ
членами, выполнЯютсЯ прежде, чем деструкторы длЯ базовых классов.
„еструкторы длЯ невиртуальных базовых классов выполнЯютсЯ прежде,
чем деструкторы длЯ виртуальных базовых классов. „еструкторы длЯ
невиртуальных базовых классов выполнЯютсЯ в порЯдке, обратном их
описанию в производном классе. „еструкторы виртуальных базовых
классов выполнЯютсЯ в порЯдке, обратном поЯвлению их при обходе
снизу и слева-направо ацикличного направленного графа базовых
классов. ‡десь "слева-направо" означает порЯдок поЯвлениЯ имен
базовых классов, который был при описании их в производном классе.
   „еструкторы длЯ элементов массива вызываютсЯ в порЯдке,
обратном вызовам при их построении.
   „еструктор может быть виртуальным.
   ‚ деструкторе можно вызывать функцию-член, см. $$R.12.7.
   Ћбъект класса с деструктором не может быть членом объединениЯ.
   „еструкторы вызываютсЯ неЯвно в следующих случаЯх:
   (1) когда исчезают из области видимости объекты auto ($$R.3.5)
   или временные объекты ($$R.12.2, $$R.8.4.3);
   (2) при завершении программы ($$R.3.4) длЯ построенных статических
   объектов ($$R.3.5);
   (3) благодарЯ обращению к операции delete ($$R.5.3.4) длЯ объектов,
   созданных с помощью операции new ($$R.5.3.3);
   (4) при Явном вызове.
Љогда деструктор вызываетсЯ операцией delete, то он освобождает
памЯть длЯ самого большего из производных классов ($$R.12.6.2) того
объекта, который использовал операцию delete() ($$R.5.3.4),
например:

           class X {
             // ...
           public:
             X(int);
             ~X();
           };

           void g(X*);

           void f()     // общий случай
           {
             X* p = new X(111);   // размещение и инициализациЯ
             g(p);
             delete p;            // освобождение и удаление
           }

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

     void* operator new(size_t, void* p) { return p; }

     void f(X* p);

     static char buf[sizeof(X)];

     void g()     // редкий, специальный случай
     {
       X* p = new(buf) X(222);  // размещение в buf[] и инициализациЯ
       f(p);
       p->X::~X();              // удаление
     }

  ЋбозначениЯ, использованные длЯ Явного вызова деструктора, можно
использовать длЯ имени любого простого типа, например,

          int* p;
          // ...
          p->int::~int();

€спользование такой записи длЯ типа, у которого нет деструктора,
проходит бесследно. „опускаЯ такую запись, мы разрешаем пользователЯм
писать программу, не задумываЯсь над тем, есть ли данного типа
деструктор.

        R.12.5 ‘вободнаЯ памЯть

Љогда создаетсЯ объект с помощью операции new, длЯ получениЯ свободной
памЯти вызываетсЯ (неЯвно) функциЯ operator new() ($$R.5.3.3).
    …сли функциЯ operator new() не может выполнить запрос, она
возвращает 0.
    ‚ классе X функциЯ X::operator new() ЯвлЯетсЯ статическим членом,
даже если она не описана Явно как static. Џервый ее параметр должен
иметь тип size_t, - зависЯщий от реализации целочисленный тип,
который определен в стандартном заголовочном файле &lt;stddef.h>, и
она должна возвращать значение типа void*, например:

           class X {
             // ...
             void* operator new(size_t);
             void* operator new(size_t, Arena*);
           };

   Џравила выбора подходЯщей функции operator new() обсуждаютсЯ
в $$R.5.3.3.
   ‚ классе X функциЯ X::operator delete() ЯвлЯетсЯ статическим
членом, даже если она не описана Явно как static. Џервый ее параметр
должен быть типа void* и можно добавлЯть второй параметр типа
size_t. Ћна не может возвращать какое-либо значение и тип
возвращаемого значениЯ должен быть void, например:

           class X {
             // ...
             void operator delete(void*);
           };

           class Y {
             // ...
             void operator delete(void*, size_t);
           };

‚ каждом классе можно описать только одну функцию operator delete(),
значит эта функциЯ не может быть перегруженной. ѓлобальнаЯ функциЯ
operator delete() имеет единственный параметр типа void*.
   …сли функциЯ описана с двумЯ формальными параметрами, она вызываетсЯ
с двумЯ параметрами, второй из которых показывает размер удалЯемого
объекта. Џередаваемый размер определЯетсЯ с помощью деструктора
(если он есть) или по типу (статическому) указателЯ на удалЯемый
объект. ЋперациЯ пройдет корректно, если тип указателЯ, заданного
как фактический параметр, будет совпадать с типом объекта (а не будет,
к примеру, просто типом указателЯ на базовый класс) или, если
этот тип ЯвлЯетсЯ типом указателЯ на базовый класс с виртуальным
деструктором.
   „лЯ массивов объектов типа класс используютсЯ глобальные функции
operator new() и operator delete() ($$R.5.3.3, $$R.5.3.4).
   Џоскольку функции X::operator new() и X::operator delete()
статические, они не могут быть виртуальными. ”ункциЯ
operator delete(), котораЯ вызываетсЯ из деструктора длЯ освобождениЯ
памЯти, выбираетсЯ по обычным правилам областей видимости,
например:

           struct B {
             virtual ~B();
             void* operator new(size_t);
             void operator delete(void*);
           };

           struct D : B {
             ~D();
             void* operator new(size_t);
             void operator delete(void*);
           };

           void f()
           {
             B* p = new D;
             delete p;
           }

‚ этом примере памЯть длЯ объекта класса D выделЯетсЯ с помощью
D::operator new(), а благодарЯ наличию виртуального деструктора,
освобождаетсЯ с помощью D::operator delete().

        R.12.6 €нициализациЯ

Ћбъект класса без конструкторов, без частных или защищенных членов,
без виртуальных функций и без базовых классов можно инициализировать
с помощью списка инициализаторов ($$R.8.4.1). Ћбъект класса с
конструктором должен инициализироватьсЯ или иметь стандартный
конструктор ($$R.12.1). ‘тандартный конструктор используетсЯ длЯ
объектов, которые не проходЯт Явной инициализации.

        R.12.6.1 џвнаЯ инициализациЯ

Ћбъекты классов с конструкторами ($$R.12.1) можно инициализировать
списком выражений, заключенным в скобки. ќтот список считаетсЯ
списком фактических параметров длЯ вызова конструктора, производЯщего
инициализацию. €наче, в качестве инициализатора задаетсЯ с помощью
операции = одно значение. Ћно используетсЯ как фактический параметр
длЯ конструктора копированиЯ. Ћбычно можно обойтись без вызова
конструктора копированиЯ, например:

           class complex {
             // ...
           public:
             complex();
             complex(double);
             complex(double,double);
             // ...
           };

           complex sqrt(complex,complex);

           complex a(1);             // инициализациЯ вызовом
                                     // complex(double)
           complex b = a;            // инициализациЯ копированием `a'
           complex c = complex(1,2); // конструктор complex(1,2)
                                     // вызываетсЯ complex(double,double)
                                     // и копируетсЯ в `c'
           complex d = sqrt(b,c);    // вызываетсЯ sqrt(complex,complex),
                                     // результат копируетсЯ в `d'
           complex e;                // инициализациЯ вызовом конструктора
           complex f = 3;            // complex(3), вызываетсЯ
                                     // complex(double) и результат
                                     // копируетсЯ в `f'

Џерегрузка операции присваиваниЯ = не оказывает влиЯние на
инициализацию.
   €нициализациЯ, происходЯщаЯ при передаче фактических параметров
и при возврате из функции, эквивалентна инициализации вида

           T x = a;

€нициализациЯ, происходЯщаЯ в выражении операции new ($$R.5.3.3) и
при инициализации базовых классов и членов, эквивалентна
инициализации вида

           T x(a);

   „лЯ массивов объектов класса с конструкторами используютсЯ при
инициализации ($$R.12.1) конструкторы как и длЯ одиночных объектов.
…сли оказалось, что инициализаторов в списке меньше, чем элементов
массива, используетсЯ стандартный конструктор ($$R.12.1). …сли его
нет, список инициализаторов должен быть полным. Џриведем пример:

           complex cc = { 1, 2 }; // ошибка: необходимо
                                  // использовать конструктор
           complex v[6] = { 1,complex(1,2),complex(),2 };

‡десь v[0] и v[3] инициализируютсЯ значением complex::complex(double),
v[1] инициализируетсЯ complex::complex(double,double), а v[2],
v[4] и v[5] инициализированы complex::complex().
   Ћбъект класса M моет быть членом класса X в одном из следующих
случаев:
  (1) M не имеет конструктора;
  (2) M имеет стандартный конструктор;
  (3) X имеет конструктор и каждый из них задает инициализатор-ctor
      ($$R.12.6.2) длЯ члена M.
‚ случае 2 при создании составного объекта вызываетсЯ стандартный
конструктор. …сли член составного объекта имеет деструктор, то он
вызываетсЯ при уничтожении составного объекта.
   Љонструкторы длЯ нелокальных статических объектов вызываютсЯ в
том порЯдке, в каком они идут в тексте программы, деструкторы
вызываютсЯ в обратном порЯдке, см. также $$R.3.4, $$R.6.7,
$$R.9.4.


        R.12.6.2 €нициализациЯ членов и базовых классов

‚ определении конструктора можно задать инициализацию прЯмых
базовых классов и членов, не наследуемых из базовых классов. ќто
особенно полезно длЯ тех объектов, констант и ссылок, длЯ которых
различаютсЯ семантики присваиваниЯ и инициализации. ЉонструкциЯ
инициализатор-ctor имеет вид

           инициализатор-ctor:
                : список-инициализаторов-членов

           список-инициализаторов-членов:
                инициализатор-члена
                инициализатор-члена , список-инициализаторов-члена

           инициализатор-члена:
                полное-имЯ-класса ( список-выражений opt )
                идентификатор

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

          struct B1 { B1(int); /* ... */ };
          struct B2 { B2(int); /* ... */ };

          struct D : B1, B2 {
              D(int);
              B1 b;
              const c;
          };

          D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4)
          { /* ... */ }
          D d(10);

  ‚ начале инициализируютсЯ базовые классы в порЯдке их описаниЯ
(независимо от порЯдка инициализаторов-членов), затем по той же
схеме инициализируютсЯ члены, и наконец выполнЯетсЯ тело D::D()
($$R.12.1). ЏорЯдок описаниЯ выдерживаетсЯ длЯ того, чтобы гарантировать,
что вложенные объекты и члены будут уничтожатьсЯ в порЯдке, обратном
их инициализации.
   Ћсобый случай представлЯют виртуальные базовые классы. Ћни создаютсЯ
прежде, чем любой невиртуальный базовый класс и в том же порЯдке,
в каком поЯвлЯютсЯ при обходе снизу и слева-направо ацикличного
направленного графа базовых классов. ЏорЯдок "слева-направо" - это
тот, в котором имена базовых классов задаютсЯ при описании в
производном классе.
   Џолным называетсЯ объект, который не ЯвлЯетсЯ вложенным объектом,
представлЯющим некоторый базовый класс. Љласс такого объекта
называют наибольшим производным классом объекта. ‚се вложенные
объекты виртуальных базовых классов инициализируютсЯ с помощью
конструктора наибольшего производного класса. …сли в конструкторе
наибольшего производного класса не задан инициализатор-члена длЯ
виртуального базового класса, тогда этот виртуальный базовый класс
должен иметь стандартный конструктор,либо не иметь никакого
конструктора. ‚сЯкий инициализатор-члена длЯ виртуального базового
класса, заданный не в конструкторе класса полного объекта, игнорируетсЯ.
Џриведем пример:

           class V {
           public:
             V();
             V(int);
             // ...
           };

           class A : public virtual V {
           public:
             A();
             A(int);
             // ...
           };

           class B : public virtual V {
           public:
             B();
             B(int);
             // ...
           };

           class C : public A, public B, private virtual V {
           public:
             C();
             C(int);
             // ...
           };

           A::A(int i) : V(i) { /* ... */ }
           B::B(int i) { /* ... */ }
           C::C(int i) { /* ... */ }

           V v(1);  // use V(int)
           A a(2);  // use V(int)
           B b(3);  // use V()
           C c(4);  // use V()

   €нициализатор-члена вычислЯетсЯ в области видимости конструктора,
в котором он поЯвилсЯ. Ќапример, в следующем фрагменте

           class X {
             int a;
           public:
             const int&amp; r;
             X()::r(a) { }
           };

X::r инициализируетсЯ длЯ каждого объекта класса X ссылкой на X::a.

        R.12.7 Љонструкторы и деструкторы

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

            class X {
            public:
              virtual void f();
              X() { f(); }  // вызов X::f()
              ~X() { f(); } // вызов X::f()
            };

            class Y : public X {
              int&amp; r;
            public:
              void f()
              {
                r++; // беда, если `r' не инициализировано
              }
              Y(int&amp; rr) ::r(rr) { }
            };

    ђезультат непосредственного или косвенного вызова из конструктора
чистой виртуальной функции длЯ инициализируемого объекта неопределен,
если только Явно не использовано уточнение имени функции ($$R.10.3).

        R.12.8 Љопирование объектов класса

Ћбъекты класса могут копироватьсЯ двумЯ способами: либо присваиванием
($$R.5.17), либо инициализацией ($$R.12.1, $$R.8.4), котораЯ может
происходить при передаче параметров ($$R.5.2.2) или
результата функции ($$R.6.6.3). „лЯ класса X эти две операции
концептуально реализуютсЯ как операциЯ присваиваниЯ и конструктор
копированиЯ ($$R.12.1). ‚ программе можно определить или одну из них,
или обе. …сли пользователь не определил их в программе, то они будут
длЯ всех членов класса X определЯтьсЯ соответственно как присваивание
по членам и инициализациЯ по членам.
    …сли все базовые классы и все члены класса X имеют конструктор
копированиЯ, в котором допустимы в качестве параметра объекты типа
const, то порождаемый конструктор копированиЯ длЯ X будет иметь
единственный параметр типа const X&amp; и записыватьсЯ так:

           X::X(const X&amp;)

    €наче, у него будет единственный параметр типа X&amp;:

           X::X(X&amp;)

и инициализациЯ копированием объектов типа const класса X будет
невозможна.
   Ђналогично, если все базовые классы и члены класса X имеют
операцию присваиваниЯ, допускающую параметры типа const, тогда
порождаемаЯ длЯ X операциЯ присваиваниЯ будет иметь единственный
параметр типа const X&amp; и записыватьсЯ так:

           X&amp; X::operator=(const X&amp;)

    €наче, у нее будет единственный параметр типа X&amp;:

           X&amp; X::operator=(X&amp;)

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

         class X {
           // ...
         public:
           X(int);
           X(const X&amp;, int = 1);
         };

         X a(1);     // вызов X(int)
         X b(a,0);   // вызов X(const X&amp;,int)
         X c = b;    // вызов X(const X&amp;,int)

    Џрисваивание объектов класса X определЯетсЯ через функцию
X::operator=(const X&amp;). ќто означает ($$R.12.3), что объекты
производного класса можно присваивать объектам общего базового
класса, например:

         class X {
         public:
           int b;
         };

         class Y : public X {
         public:
           int c;
         };

         void f()
         {
           X x1;
           Y y1;
           x1 = y1;  // нормально
           y1 = x1;  // ошибка
         }

  ‚ этом примере y1.b присваиваетсЯ x1.b, а x1.c не копируетсЯ.
    Љопирование одного объекта в другой с помощью стандартной
операции копированиЯ или стандартного конструктора копированиЯ
не изменЯет структуру обоих объектов. Џриведем пример:

          struct s {
            virtual f();
            // ...
          };

          struct ss : public s {
            f();
            // ...
          };

          void f()
          {
            s a;
            ss b;
            a = b;     // на самом деле выполнЯетсЯ a.s::operator=(b)
            b = a;     // ошибка
            a.f();     // вызов s::f
            b.f();     // вызов ss::f
            (s&amp;)b = a; // присваивание a  b
                       // на самом деле выполнЯетсЯ ((s&amp;)b).s::operator=(a)
            b.f();     // все еще вызов ss::f
          }

‚ызов a.f() приведет к вызову s::f() (как и должно быть длЯ объекта
класса s ($$R.10.2)), а вызов b.f() приведет к вызову ss::f()
( как и должно быть длЯ объекта класса ss).

        R.13 Џерегрузка

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

          double abs(double);
          int abs(int);

           abs(1);   // вызов abs(int)
           abs(1.0); // вызов abs(double)

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

           int f(int i)
           {
             // ...
            }

            int f(int&amp; r)  // ошибка: типы функций
            {              // недостаточно различны
              // ...
             }

Ђналогично, поскольку длЯ любом типе T длЯ самого T, const T и
volatile T допустимо одно и то же множество инициализирующих
значений, функции, типы параметров которых отличаютсЯ только
указанной спецификацией, не могут иметь одинаковые имена. Ћднако,
различить const T&amp;, volatile T&amp; и просто T&amp; можно, поэтому допустимы
определениЯ функций с одним именем, которые различаютсЯ только
в указанном отношении. Ђналогично, допустимы определениЯ функций
с одним именем, типы параметров которых различаютсЯ только как
типы вида const T*, volatile T* и просто T*.
   Ќе могут иметь одинаковые имена функции, которые отличаютсЯ
только типом возвращаемого значениЯ.
   Ќе могут иметь одинаковые имена функции-члены, одна из которых
статическаЯ, а другаЯ нет ($$R.9.4).
   ‘ помощью конструкции typedef не создаютсЯ новые типы,
а только определЯетсЯ синоним типа ($$R.7.1.3), поэтому функции,
которые отличаютсЯ только за счет использованиЯ типов, определенных с
помощью typedef, не могут иметь одинаковые имена. Џриведем
пример:

        typedef int Int;

        void f(int i) { /* ... */ }
        void f(Int i) { /* ... */ } // ошибка: переопределение f

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

        enum E { a };

        void f(int i) { /* ... */ }
        void f(E i)   { /* ... */ }

   ’ипы параметров, которые различаютсЯ только тем, что в одном
используетсЯ указатель *, а в другом массив [], считаютсЯ идентичными.
Ќапомним, что длЯ типа параметра важны только второй и последующие
индексы многомерного массива ($$R.8.2.4). Џодтвердим сказанное
примером:

        f(char*);
        f(char[]);       // идентично f(char*);
        f(char[7]);      // идентично f(char*);
        f(char[9]);      // идентично f(char*);
        g(char(*)[10]);
        g(char[5][10]);  // идентично g(char(*)[10]);
        g(char[7][10]);  // идентично g(char(*)[10]);
        g(char(*)[20]);  // отлично от g(char(*)[10]);

        R.13.1 ‘опоставление описаний

„ва описаниЯ функций с одинаковыми именами относЯтсЯ к одной и той
же функции, если они находЯтсЯ в одной области видимости и имеют
идентичные типы параметров ($$R.13). ”ункциЯ-член производного
класса относитсЯ к иной области видимости, чем функциЯ-член
базового класса с тем же именем. ђассмотрим пример:

        class B {
        public:
          int f(int);
        };

        class D : public B {
        public:
          int f(char*);
        };

‡десь D::f(char*) скорее скрывает B::f(int), чем перегружает эту
функцию.

        void h(D* pd)
        {
          pd->f(1);     // ошибка: D::f(char*) скрывает B::f(int)
          pd->B::f(1);  // нормально
          pd->f("Ben"); // нормально, вызов D::f
        }

”ункциЯ, описаннаЯ локально, находитсЯ в иной области видимости, чем
функциЯ с файловой областью видимости.

        int f(char*);
        void g()
        {
          extern f(int);
          f("asdf");  // ошибка: f(int) скрывает f(char*) поэтому
                      // в текущей области видимости нет f(char*)
        }

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

         class buffer {
         private:
           char* p;
           int size;

         protected:
           buffer(int s, char* store) { size = s; p = store; }
           // ...

         public:
           buffer(int s) { p = new char[size = s]; }
         };

        R.13.2 ‘опоставление параметров

Џри вызове функции с данным именем происходит выбор из всех
функций с этим именем, которые находЯтсЯ в текущей области видимости, и
длЯ которых существуют преобразованиЯ типа, делающие вызов возможным.
‚ыбираетсЯ та функциЯ, котораЯ наиболее соответствует фактическим
параметрам. Ћна находитсЯ в области пересечениЯ множеств
функций, каждое из которых наиболее соответствуют вызову по данному
фактическому параметру. ЋперациЯ вызова считаетсЯ допустимой, если в этом
пересечении находитсЯ только один член. ”ункциЯ, выбраннаЯ таким образом,
должна более любой другой функции с тем же именем соответствовать
вызову, хотЯ бы по одному из параметров (необЯзательно это
будет один и тот же параметр длЯ разных функций). ‚ противном случае,
вызов считаетсЯ недопустимым.
    Џри сопоставлении параметров рассматривают функцию с числом
стандартных значений параметров ($$R.8.2.6), равным n, как
n+1 функций с различным числом параметров.
   Џри сопоставлении параметров нестатическую функцию-член
рассматривают как функцию, имеющую дополнительный параметр,
указывающий на объект, длЯ которого вызываетсЯ функциЯ. ќтот
дополнительный формальный параметр должен сопоставлЯтьсЯ или
с объектом, или с указателем на объект, заданными в Явной операции
вызова функции-члена ($$R.5.2.4), или же с первым операндом
перегруженной функции operator ($$R.13.4). „лЯ этого дополнительного
параметра не используетсЯ никаких временных объектов, а длЯ достижениЯ
сопоставлениЯ не производитсЯ никаких пользовательских преобразований
типа.
   …сли Явно вызываетсЯ член класса X, используЯ указатель и операцию
->, то считаетсЯ, что дополнительный параметр имеет тип const* X длЯ
членов типа const, volatile* X длЯ членов типа volatile и
X* длЯ всех остальных членов. …сли Явно вызываетсЯ функциЯ-член,
используЯ объект и операцию ., а также, если  вызываетсЯ функциЯ
длЯ первого операнда перегруженной функции operator ($$R.9.4),
то считаетсЯ, что дополнительный параметр имеет тип: const X&amp; длЯ
членов типа const, volatile X&amp; длЯ членов типа volatile и  X&amp;
длЯ всех остальных членов. Џервый операнд длЯ ->* и .* рассматриваетсЯ
так же, как и первый операнд длЯ -> и . соответственно.
   ќллипсис в списке формальных параметров ($$R.8.2.5) может
сопоставлЯтьсЯ с фактическим параметром любого типа.
   „лЯ данного фактического параметра допускаетсЯ только такаЯ
последовательность преобразований типа, котораЯ содержит не более
одного пользовательского преобразованиЯ. …е нельзЯ сократить,
исключив одно или несколько преобразований, до последовательности,
котораЯ также приводит к типу, сопоставимому с типом рассматриваемого
формального параметра. ’акаЯ последовательность преобразований
называетсЯ наиболее соответствующей последовательностью.
   Ќапример, последовательность int->float->double задает
преобразование int в double, но ее нельзЯ назвать наиболее
соответствующей последовательностью, поскольку в ней содержитсЯ
более короткаЯ последовательность int->double.
    Љроме описанных ниже случаев, следующие тривиальные
преобразованиЯ  типа T не влиЯют на свойство последовательности
быть наиболее соответствующей:

       исходный тип      тип результата
           T                 T&amp;
           T&amp;                T
           T[]               T*
           T(параметры)      T(*)(параметры)
           T                 const T
           T                 volatile T
           T*                const T*
           T*                volatile T*

Џоследовательности тривиальных преобразований, которые отличаютсЯ
только порЯдком преобразований, считаютсЯ совпадающими. Ћтметим,
что длЯ функций с формальным параметром типа T, const T, volatile T,
T&amp;, const T&amp; и volatile T&amp; допустим фактический параметр из одно и
того же множества значений. Џри необходимости длЯ разделениЯ
последовательностей преобразований используютсЯ спецификации const и
volatile, как описано в правиле [1] ниже.
   „лЯ формального параметра типа T&amp; требуетсЯ временнаЯ переменнаЯ
в случаЯх, если: фактический параметр не ЯвлЯетсЯ адресом, или имеет тип,
отличный от T, в том числе тип volatile. Ќаличие такой переменной
не влиЯет на сопоставление параметров. Ћднако, оно может повлиЯть
на допустимость результата сопоставлениЯ, т.к. временную переменную
нельзЯ использовать длЯ инициализации ссылок, не ЯвлЯющихсЯ
const ($$R.8.4.3).
   Џоследовательности преобразований рассматриваютсЯ согласно
следующим правилам:
   [1] ’очное сопоставление. Џоследовательности из нулЯ или более
       тривиальных преобразований предпочтительнее любых других
       последовательностей. €з более сложных последовательностей
       наиболее предпочтительны те, в которых нет преобразований
       T* в const T*, T* в volatile T*, T&amp; в const T&amp; или
       T&amp; в volatile T&amp;.
   [2] ‘опоставление со стандартными преобразованиЯми основных типов.
       €з последовательностей, не относЯщихсЯ к [1], наиболее
       предпочтительны те, которые содержат только стандартные
       целочисленные преобразованиЯ ($$R.4.1),
       преобразованиЯ float в double и тривиальные преобразованиЯ.
   [3] ‘опоставление с любыми стандартными преобразованиЯми.
       из последовательностей, не относЯщихсЯ к [2], наиболее
       предпочтительны те, которые содержат только любые
       стандартные преобразованиЯ ($$R.4.1, $$R.4.2, $$R.4.3, $$R.4.4,
       $$R.4.5, $$R.4.6, $$R.4.7, $$R.4.8) и тривиальные
       преобразованиЯ. „лЯ этих последовательностей если A ЯвлЯетсЯ
       прЯмым или косвенным общим базовым длЯ класса B,
       то преобразование B* в A* предпочтительнее преобразованиЯ B*
       в void* или const void*. „алее, если B ЯвлЯетсЯ прЯмым или
       косвенным базовым классом длЯ C, то предпочтительнее преобразование
       C* в B*, чем C* в A*, и предпочтительнее преобразование C&amp; в B&amp;,
       чем C&amp; в A&amp;. €ерархиЯ классов выступает здесь критерий отбора
       преобразований указателЯ в член ($$R.4.8).
   [4] ‘опоставление с пользовательскими преобразованиЯми.
       €з последовательностей, не относЯщихсЯ к [3], наиболее
       предпочтительны те, которые содержат только
       пользовательские ($$R.12.3), стандартные ($$R.4) и тривиальные
       преобразованиЯ.
   [5] ‘опоставление с эллипсисом.
       Џоследовательности, которые требуют сопоставлениЯ с эллипсисом,
       считаютсЯ наименее предпочтительными.
   Џользовательские преобразованиЯ выбирают, исходЯ из типа
переменной, котораЯ инициализируетсЯ или которой присваиваетсЯ
значение.

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

        void f(Y y)
        {
          int i = y;    // вызов Y::operator int()
          double d;
          d = y;        // вызов Y::operator double()
          float f = y;  // ошибка: неоднозначность
        }

  ‘тандартные преобразованиЯ ($$R.4) могут применЯтьсЯ к параметру,
как до пользовательского преобразованиЯ, так и после него.

        struct S { S(long); operator int(); };

        void f(long), f(char*);
        void g(S), g(char*);
        void h(const S&amp;), h(char*);

        void k(S&amp; a)
        {
          f(a);    // f(long(a.operator int()))
          g(1);    // g(S(long(1)))
           h(1);   // h(S(long(1)))
        }

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

        class x {
        public:
           x(int);
        };

        class y {
        public:
           y(long);
        };

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

        void g()
        {
          f(1);  // неоднозначность
        }

‡десь вызов f(1) неоднозначен. ЌесмотрЯ на то, что длЯ вызова
f(y(long(1))) требуетсЯ на одно стандартное преобразование больше,
чем длЯ вызова f(x(1)), второй вызов не ЯвлЯетсЯ предпочтительным.
   ЏреобразованиЯ с помощью конструктора ($$R.12.1) и с помощью
функции преобразованиЯ ($$R.12.3.2) равноправны.

        struct X {
          operator int();
        };

        struct Y {
          Y(X);
        };

        Y operator+(Y,Y);

        void f(X a, X b)
        {
           a+b;  // ошибка, неоднозначность:
                 //   operator+(Y(a), Y(b)) или
                 //   a.operator int() + b.operator int()
        }

        R.13.3 Ђдрес перегруженной функции

Љогда функциЯ с некоторым именем используетсЯ без параметров, среди
всех функций с таким именем в текущей области видимости выбираетсЯ
единственнаЯ, котораЯ точно соответствует назначению. Ќазначением
может быть:
       инициализируемый объект ($$R.8.4);
       леваЯ часть операции присваиваниЯ ($$R.5.17);
       формальный параметр функции ($$R.5.2.2);
       формальный параметр пользовательской операции ($$R.13.4);
       тип значениЯ, возвращаемого функцией ($$R.8.2.5).
  Ћтметим, что если f() и g() ЯвлЯютсЯ перегруженными функциЯми, то
длЯ правильной интерпретации f(&amp;g) или эквивалентного выражениЯ
f(g) нужно рассмотреть пересечение множеств выбора длЯ f() и g().
Џриведем пример:

       int f(double);
       int f(int);
       int (*pfd)(double) = &amp;f;
       int (*pfi)(int) = &amp;f;
       int (*pfe)(...) = &amp;f;   // ошибка: несоответствие типов

ЏоследнЯЯ инициализациЯ ошибочна, не из-за неоднозначности, а
потому, что не определено ни одной функции f() типа int(...).
   Ћтметим, что не существует никакого стандартного преобразованиЯ
($$R.4) указателЯ на функцию одного типа в указатель на функцию
другого типа ($$R.4.6). ‚ частности, даже если B ЯвлЯетсЯ общим
базовым классом D, две следующие инициализации недопустимы:

       D* f();
       B* (*p1)() = &amp;f;     // ошибка

       void g(D*);
       void (*p2)(B*) = &amp;g; // ошибка

        R.13.4 Џерегруженные операции

Џерегружать можно большинство операций.

     имЯ-функции-оператор:
         operator операциЯ

     операциЯ: один из
               new delete
               +   -   *   /   %   ^   &amp;   |   ~
               !   =   &lt;   >   +=  -=  *=  /=  %=
               ^=  &amp;=  |=  &lt;&lt;  >>  >>= &lt;&lt;= ==  !=
               &lt;=  >=  &amp;&amp;  ||  ++  --  ,   ->* ->
               ()  []

„ве последние операции - это вызов функции ($$R.5.2.2) и индексациЯ
($$R.5.2.1).
    Њожно перегружать следующие (как бинарные, так и унарные)
операции:

            +  -  *  &amp;

    ЌельзЯ перегружать следующие операции:

          .  .*  ::  ?:  sizeof

а также и специальные символы препроцессора # и ## ($$R.16).
  Ћбычно функции, задающие операции (функциЯ-оператор) не вызываютсЯ
Явно, к ним обращаютсЯ длЯ выполнениЯ операций ($$R.13.4.1, $$R.13.4.2).
Ћднако, к ним можно обращатьсЯ Явно, например:

         complex z = a.operator+(b);  // complex z = a+b
         void* p = operator new(sizeof(int)*n);

  Ћперации new и delete описаны в $$R.5.3.3 и $$R.5.3.4 и к ним
не относЯтсЯ перечислЯемые ниже правила.
  ”ункциЯ-оператор может быть функцией-членом или иметь по крайней
мере один параметр типа класс или ссылка на класс. ЌельзЯ изменить
приоритет, порЯдок выполнениЯ или число операндов операции, но
можно изменить предопределенное назначение таких операций:  =,
унарнаЯ &amp; и ,(запЯтой), если они применЯютсЯ к объекту типа класс.
‡а исключением функции operator=(), функциЯ-оператор наследуетсЯ.
Џравила длЯ operator=() даны в $$R.12.8.
   ќквивалентность некоторых операций над основными типами
(например, ++a эквивалентно a+=1) может не сохранЯтьсЯ длЯ таких
же операций над классами. „лЯ некоторых операций требуетсЯ, чтобы
в случае использованиЯ основных типов операнд был адресом (например,
длЯ +=). ќто требование может быть снЯто, если операциЯ задана над
классами.
   ЏерегруженнаЯ операциЯ не может иметь стандартные значениЯ
параметров ($$R.8.2.6).
   Ћперации, которые Явно не указаны в $$R.13.4.3-$$R.13.4.7,
действуют как обычные унарные или бинарные операции, подчинЯющиесЯ
правилам, приведенным в $$R.13.4.1 или $$R.13.4.2.

        R.13.4.1 “нарные операции

Џрефиксную унарную операцию можно задать с помощью нестатической
функции-члена ($$R.9.3), без параметров или с помощью
функции, не ЯвлЯющейсЯ членом, с одним параметром. ’аким образом,
длЯ всЯкой префиксной унарной операции @, выражение @x может
интерпретироватьсЯ как x.operator@() или как operator@(x).
…сли описаны функции-операторы обоих видов, то какаЯ из них будет
использоватьсЯ при вызове, определЯетсЯ правилами сопоставлениЯ
параметров ($$R.13.2). Џостфиксные унарные операции, такие как ++ и -- ,
объЯснЯютсЯ в $$R.13.4.7.

        R.13.4.2 Ѓинарные операции

Ѓинарную операцию можно задать с помощью нестатической
функции-члена ($$R.9.3), имеющей один параметр, или с помощью
функции, не ЯвлЯющейсЯ членом, с двумЯ параметрами. ’аким образом,
длЯ всЯкой бинарной операции @ выражение x@y может интерпретироватьсЯ
как x.operator@(y) или как operator@(x,y). …сли описаны
функции-операторы обоих видов, то какаЯ из них будет использоватьсЯ
при вызове, определЯетсЯ правилами сопоставлениЯ параметров ($$R.13.2).

        R.13.4.3 ЏрисваиваниЯ

”ункциЯ присваиваниЯ operator=() должна быть нестатической
функцией-членом. Ћна не наследуетсЯ ($$R.12.8). Ѓолее того, если
пользователь не определил длЯ класса X функцию operator=, то
используетсЯ стандартнаЯ функциЯ operator=, котораЯ определЯетсЯ
как присваивание по членам длЯ класса X.

     X&amp; X::operator=(const X&a