/ 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&&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& 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, - зависящий от реализации целочисленный тип, который определен в стандартном заголовочном файле <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& 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& r; public: void f() { r++; // беда, если `r' не инициализировано } Y(int& 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& и записываться так: X::X(const X&) Иначе, у него будет единственный параметр типа X&: X::X(X&) и инициализация копированием объектов типа const класса X будет невозможна. Аналогично, если все базовые классы и члены класса X имеют операцию присваивания, допускающую параметры типа const, тогда порождаемая для X операция присваивания будет иметь единственный параметр типа const X& и записываться так: X& X::operator=(const X&) Иначе, у нее будет единственный параметр типа X&: X& X::operator=(X&) и присваивание копированием объектов класса X типа const будет невозможно. Стандартная операция присваивания возвращает ссылку на объект, который нужно было копировать. Объекты, представляющие виртуальные базовые классы, будут инициализироваться только один раз с помощью порождаемого конструктора копирования. Объекты, представляющие виртуальные базовые классы, допускают присваивания им только один раз с помощью порождаемой операции присваивания. Присваивание по членам и инициализация по членам означают следующее: если класс X имеет в качестве члена класс M, для реализации присваивания и инициализации члена используются операции присваивания в M и конструктор копирования M соответственно. Если класс имеет член типа const, или член, являющийся ссылкой, или член или базовый класс такого класса, где функция operator=() является частной, то для него стандартная операция присваивания не может быть создана. Аналогично, если член или базовый класс класса M имеет частный конструктор копирования, то стандартный конструктор копирования для такого класса не может быть создан. Пока не появится необходимость в определении, стандартные присваивание и конструктор копирования будут только описаны (т.е. не будет создано тело функции). Иными словами, функция X::operator=() будет порождена только тогда, когда нет явного описания операций присваивания, а объект класса X присваивается объекту класса X или объекту класса, производного от X, или вычисляется адрес функции X::operator=(). Аналогичная ситуация с инициализацией. Если присваивание и конструктор копирования описаны неявно, то они будут общими функциями-членами и операция присваивания для класса X определяется таким образом, что ее результатом является ссылка типа X& на объект, которому присваивают. Если в классе X есть функция X::operator=(), параметром которой является сам класс X, то стандартное присваивание не будет порождаться. Если в классе определен какой-либо конструктор копирования, то стандартный конструктор копирования не будет порождаться. Приведем пример: class X { // ... public: X(int); X(const X&, int = 1); }; X a(1); // вызов X(int) X b(a,0); // вызов X(const X&,int) X c = b; // вызов X(const X&,int) Присваивание объектов класса X определяется через функцию X::operator=(const X&). Это означает ($$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&)b = a; // присваивание a b // на самом деле выполняется ((s&)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& допустимо одно и то же множество инициализирующих значений, функции, типы параметров которых различаются только использованием, или не использованием ссылки, не могут иметь одинаковые имена, например: int f(int i) { // ... } int f(int& r) // ошибка: типы функций { // недостаточно различны // ... } Аналогично, поскольку для любом типе T для самого T, const T и volatile T допустимо одно и то же множество инициализирующих значений, функции, типы параметров которых отличаются только указанной спецификацией, не могут иметь одинаковые имена. Однако, различить const T&, volatile T& и просто T& можно, поэтому допустимы определения функций с одним именем, которые различаются только в указанном отношении. Аналогично, допустимы определения функций с одним именем, типы параметров которых различаются только как типы вида 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& для членов типа const, volatile X& для членов типа volatile и X& для всех остальных членов. Первый операнд для ->* и .* рассматривается так же, как и первый операнд для -> и . соответственно. Эллипсис в списке формальных параметров ($$R.8.2.5) может сопоставляться с фактическим параметром любого типа. Для данного фактического параметра допускается только такая последовательность преобразований типа, которая содержит не более одного пользовательского преобразования. Ее нельзя сократить, исключив одно или несколько преобразований, до последовательности, которая также приводит к типу, сопоставимому с типом рассматриваемого формального параметра. Такая последовательность преобразований называется наиболее соответствующей последовательностью. Например, последовательность int->float->double задает преобразование int в double, но ее нельзя назвать наиболее соответствующей последовательностью, поскольку в ней содержится более короткая последовательность int->double. Кроме описанных ниже случаев, следующие тривиальные преобразования типа T не влияют на свойство последовательности быть наиболее соответствующей: исходный тип тип результата T T& T& T T[] T* T(параметры) T(*)(параметры) T const T T volatile T T* const T* T* volatile T* Последовательности тривиальных преобразований, которые отличаются только порядком преобразований, считаются совпадающими. Отметим, что для функций с формальным параметром типа T, const T, volatile T, T&, const T& и volatile T& допустим фактический параметр из одно и того же множества значений. При необходимости для разделения последовательностей преобразований используются спецификации const и volatile, как описано в правиле [1] ниже. Для формального параметра типа T& требуется временная переменная в случаях, если: фактический параметр не является адресом, или имеет тип, отличный от T, в том числе тип volatile. Наличие такой переменной не влияет на сопоставление параметров. Однако, оно может повлиять на допустимость результата сопоставления, т.к. временную переменную нельзя использовать для инициализации ссылок, не являющихся const ($$R.8.4.3). Последовательности преобразований рассматриваются согласно следующим правилам: [1] Точное сопоставление. Последовательности из нуля или более тривиальных преобразований предпочтительнее любых других последовательностей. Из более сложных последовательностей наиболее предпочтительны те, в которых нет преобразований T* в const T*, T* в volatile T*, T& в const T& или T& в volatile T&. [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& в B&, чем C& в A&. Иерархия классов выступает здесь критерий отбора преобразований указателя в член ($$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&), h(char*); void k(S& 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(&g) или эквивалентного выражения f(g) нужно рассмотреть пересечение множеств выбора для f() и g(). Приведем пример: int f(double); int f(int); int (*pfd)(double) = &f; int (*pfi)(int) = &f; int (*pfe)(...) = &f; // ошибка: несоответствие типов Последняя инициализация ошибочна, не из-за неоднозначности, а потому, что не определено ни одной функции f() типа int(...). Отметим, что не существует никакого стандартного преобразования ($$R.4) указателя на функцию одного типа в указатель на функцию другого типа ($$R.4.6). В частности, даже если B является общим базовым классом D, две следующие инициализации недопустимы: D* f(); B* (*p1)() = &f; // ошибка void g(D*); void (*p2)(B*) = &g; // ошибка R.13.4 Перегруженные операции Перегружать можно большинство операций. имя-функции-оператор: operator операция операция: один из new delete + - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && || ++ -- , ->* -> () [] Две последние операции - это вызов функции ($$R.5.2.2) и индексация ($$R.5.2.1). Можно перегружать следующие (как бинарные, так и унарные) операции: + - * & Нельзя перегружать следующие операции: . .* :: ?: 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 и к ним не относятся перечисляемые ниже правила. Функция-оператор может быть функцией-членом или иметь по крайней мере один параметр типа класс или ссылка на класс. Нельзя изменить приоритет, порядок выполнения или число операндов операции, но можно изменить предопределенное назначение таких операций: =, унарная & и ,(запятой), если они применяются к объекту типа класс. За исключением функции 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& X::operator=(const X&a