complex operator*(complex b)

{ return complex(re*b.re,im*b.im); }

обе функции operator* являются глобальными

(no сравнению с предыдуидей версией

здесь добавлена одна функция) friend complex operator*(complex a.double b) функция 1

{ return complex(a.re*b,a.im*b); } friend complex operator*(double b.complex a) функция 2

{ return complex(a.re*b,a.im*b); } friend ostream& operator (ostream& stream.complex C) { stream C.re \t. C.im endl; return stream; }

void main(void)

{ complex x(2,3);

cout x*6; Вызывается функция 1. Результат: 12 18 cout 8*x; Вызывается функция 2. Результат: 16 24

5.4. Преобразование типа

По соглашению, принятому в языке С++, конструктор с одним аргументом можно не вызывать непосредственно. Рассмотрим пример:

class my class { int a,b;

my class(int x) { a=x; b=10; }

Теперь можно описать и инициализироват!. объекты класса my class:

my class my object1 = my class(50); my class my object2 = 50;

Оба объекта: my objectl и my object2 будут инициализированы одинаково посредством вызова конструктора my class (50). В результате мы можем присваивать значение перемен-

НОЙ, имеющей базовый тип (т. е. тип данных, определенный в самом языке), другой переменной, которая имеет новый тип (т. е. тип, определенный пользователем).

Диаметрально противоположные действия являются более сложными. Рассмотрим пример:

class my class { double d;

public:

my class(double x) : d(x) { } void mainQ

{ my class my object = 10.83; нет ошибки double my double = my object; ошибка, так как

неизвестно, как преобразовать тип объекта T)y object к базовому типу my double

Чтобы разрешить выполнение обычных операций, в которых участвуют переменные базовых типов (например, double в приведенном выше примере), можно задать необходимые преобразования с помощью соответствующей функции operator, например добавить в класс my class следующую функцию:

operator double() { return d; }

Теперь в выражении:

double my doubie = my object;

не будет ошибки, так как мы задали прямое преобразование типа.

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

class my class1 {

my class1(int); }; class my class2 {

my class2(int); }; my class1 my function(my class1); объявление my class2 my function(my class2); функций, которые

где-то описаны

void function(void)

{ my function(5); ошибка, так как неизвестно, какой объект строить: my function(my class1(5)) или my function{my class2(5)) my function(my class1(5)); нет ошибки my function{my class2(5)); нет ошибки

По соглашега1Ю, принятому в языке С++, разрешается выполнять только одноуровневое подразумеваемое преобразование типа. Рассмотрим пример:

class my class1 {

my class1(char*); }; class my class2 {

my class2(my class1); }; my class2 my function(my class2); void function(void)

{ my function( Aveiro ); ошибка, так как здесь

необходимо выполнить два уровня преобразования: my function(my class2(my class1( Aveiro ))), где первый уровень - это my class2( Aveiro ) и второй - my class2(my class1 ( Aveiro )) my function(my class2( Aveiro ));

нет ошибки, так как мы явно выполнили преобразование первого уровня

Преобразования типов, введенные пользователем, рассматриваются лишь в том случае, если нельзя выполнить стан-