Бьерн Страуструп. Язык программирования С++
Предопределенные свойства операций
жүктеу/скачать 3.27 Mb.
|
- Бұл бет үшін навигация:
- 7.2.3 Операторные функции и пользовательские типы
- 7.3 Пользовательские операции преобразования типа
- 7.3.1 Конструкторы
7.2.2 Предопределенные свойства операцийИспользуется только несколько предположений о свойствах пользовательских операций. В частности, operator=, operator[], operator() и operator-> должны быть нестатическими функциями-членами. Этим обеспечивается то, что первый операнд этих операций является адресом. Для некоторых встроенных операций их интерпретация определяется как комбинация других операций, выполняемых над теми же операндами. Так, если a типа int, то ++a означает a+=1, что в свою очередь означает a=a+1. Такие соотношения не сохраняются для пользовательских операций, если только пользователь специально не определил их с такой целью. Так, определение operator+=() для типа complex нельзя вывести из определений complex::operator+() и complex operator=(). По исторической случайности оказалось, что операции = (присваивание), &(взятие адреса) и , (операция запятая) обладают предопределенными свойствами для объектов классов. Но можно закрыть от произвольного пользователя эти свойства, если описать эти операции как частные: class X { // ...
private: void operator=(const X&); void operator&(); void operator,(const X&); // ... };
{ a= b; // ошибка: операция = частная &a; // ошибка: операция & частная a,b // ошибка: операция , частная }
определений этим операциям иное значение. 7.2.3 Операторные функции и пользовательские типыОператорная функция должна быть либо членом, либо иметь по крайней мере один параметр, являющийся объектом класса (для функций, переопределяющих операции new и delete, это не обязательно). Это правило гарантирует, что пользователь не сумеет изменить интерпретацию выражений, не содержащих объектов пользовательского типа. В частности, нельзя определить операторную функцию, работающую только с указателями. Этим гарантируется, что в С++ возможны расширения, но не мутации (не считая операций =, &, и , для объектов класса).
Операторная функция, имеющая первым параметр основного типа, не может быть функцией-членом. Так, если мы прибавляем комплексную переменную aa к целому 2, то при подходящем описании функции-члена aa+2 можно интерпретировать как aa.operator+(2), но 2+aa так интерпретировать нельзя, поскольку не существует класса int, для которого + определяется как 2.operator+(aa). Даже если бы это было возможно, для интерпретации aa+2 и 2+aa пришлось иметь дело с двумя разными функциями-членами. Этот пример тривиально записывается с помощью функций, не являющихся членами. Каждое выражение проверяется для выявления неоднозначностей. Если пользовательские операции задают возможную интерпретацию выражения, оно проверяется в соответствии с правилами $$R.13.2. 7.3 Пользовательские операции преобразования типаОписанная во введении реализация комплексного числа является слишком ограниченной, чтобы удовлетворить кого-нибудь, и ее надо расширить. Делается простым повторением описаний того же вида, что уже были применены:
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-(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; }
писать для каждой комбинации complex и double свою функцию. Более того, разумные средства для комплексной арифметики должны предоставлять десятки таких функций (посмотрите, например, как описан тип complex в 7.3.1 КонструкторыВместо того, чтобы описывать несколько функций, можно описать конструктор, который из параметра double создает complex:
// ...
complex(double r) { re=r; im=0; } };
традиционный способ расширения вещественной прямой до комплексной плоскости. Конструктор с единственным параметром не обязательно вызывать явно:
complex z2 = 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& operator+=(complex); complex& operator*=(complex); complex& operator*=(double);
};
для работы с пользовательскими типами, поскольку обычно запись с ними короче, чем с их обычными "двойниками" * и + , а кроме того они могут повысить скорость выполнения программы за счет исключения временных переменных: inline complex& 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& matrix::operator*=(const matrix& a) { // ... return *this; }
{ matrix prod = a; prod *= b; return prod; }
никаких особых прав доступа к классу, к которому она применяется, т.е. эта операция не должна быть другом или членом этого класса. Пользовательское преобразование типа применяется только в том случае, если оно единственное($$7.3.3). Построенный в результате явного или неявного вызова конструктора, объект является автоматическим, и уничтожается при первой возможности,- как правило сразу после выполнения оператора, в котором он был создан.
жүктеу/скачать 3.27 Mb. Достарыңызбен бөлісу:
|