Определяемое Преобразование Типа

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

Например:

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, 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);

// …

};

Теперь, имея описание 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, как это делалось выше для operator+(), невыносимо нудно. Кроме того, близкие к реальности средства комплексной арифметики должны предоставлять по меньшей мере дюжину таких функций; посмотрите, например, на тип complex.

Конструкторы

Альтернативу использованию нескольких функций (перегруженных) составляет описание конструктора, который по заданному double создает complex.

Например:

Class complex {

// …

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

};

Конструктор, требующий только один параметр, необязательно вызывать явно:

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 и целые константы, стали бы допустимы. Целая константа будет интерпретироваться как complex с нулевой мнимой частью. Например, a=b*2 означает:

A=operator*( b, complex( double(2), double(0) ) )

Определенное пользователем преобразование типа применяется неявно только тогда, когда оно является единственным.

Объект, сконструированный с помощью явного или неявного вызова конструктора, является автоматическим и будет уничтожен при первой возможности, обычно сразу же после оператора, в котором он был создан.

Операции Преобразования

Использование конструктора для задания преобразования типа является удобным, но имеет следствия, которые могут оказаться нежелательными:

Не может быть неявного преобразования из определенного пользователем типа в основной тип (поскольку основные типы не являются классами);

Невозможно задать преобразование из нового типа в старый, не изменяя описание старого; и

Невозможно иметь конструктор с одним параметром, не имея при этом преобразования.

Последнее не является серьезной проблемой, а с первыми двумя можно справиться, определив для исходного типа операцию преобразования. Функция член X::operator T(), где T – имя типа, определяет преобразование из X в T. Например, можно определить тип tiny (крошечный), который может иметь значение только в диапазоне 0…63, но все равно может свободно сочетаться в целыми в арифметических операциях:

Class tiny {

Char v;

Int assign(int i)

{ return v = (i&;~63) ? (error(“ошибкадиапазона”),0) : i; }

Public:

Tiny(int i) { assign(i); }

Tiny(tiny&; i) { v = t. v; }

Int operator=(tiny&; i) { return v = t. v; }

Int operator=(int i) { return assign(i); }

Operator int() { return v; }

}

Диапазон значения проверяется всегда, когда tiny инициализируется int, и всегда, когда ему присваивается int. Одно tiny может присваиваться другому без проверки диапазона. Чтобы разрешить выполнять над переменными tiny обычные целые операции, определяется tiny::operator int(), неявное преобразование из int в tiny. Всегда, когда в том месте, где требуется 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<>x выше возвращает istream&;. Это значение неявно преобразуется к значению, которое указывает состояние cin, а уже это значение может проверяться оператором while. Однако определять преобразование из оного типа в другой так, что при этом теряется информация, обычно не стоит.

Неоднозначности

Присваивание объекту (или инициализация объекта) класса X является допустимым, если или присваиваемое значение является X, или существует единственное преобразование присваиваемого значения в тип X.

В некоторых случаях значение нужного типа может сконструироваться с помощью нескольких применений конструкторов или операций преобразования. Это должно делаться явно; допустим только один уровень неявных преобразований, определенных пользователем. Иногда значение нужного типа может быть сконструировано более чем одним способом. Такие случаи являются недопустимыми.

Например:

Class x { /* … */ x(int); x(char*); };

Class y { /* … */ y(int); };

Class z { /* … */ z(x); };

Overload f;

X f(x);

Y f(y);

Z g(z);

F(1); // недопустимо: неоднозначность f(x(1)) или f(y(1))

F(x(1));

F(y(1));

G(“asdf”); // недопустимо: g(z(x(“asdf”))) не пробуется

G(z(“asdf”));

Определенные пользователем преобразования рассматриваются только в том случае, если без них вызов разрешить нельзя.

Например:

Class x { /* … */ x(int); }

Overload h(double), h(x);

H(1);

Вызов мог бы быть проинтерпретирован или как h(double(1)), или как h(x(1)), и был бы недопустим по правилу единственности. Но первая интерпретация использует только стандартное преобразование и она будет выбрана по правилам. Правила преобразования не являются ни самыми простыми для реализации и документации, ни наиболее общими из тех, которые можно было бы разработать. Возьмем требование единственности преобразования. Более общий подход разрешил бы компилятору применять любое преобразование, которое он сможет найти; таким образом, не нужно было бы рассматривать все возможные преобразования перед тем, как объявить выражение допустимым. К сожалению, это означало бы, что смысл программы зависит от того, какое преобразование было найдено. В результате смысл программы неким образом зависел бы от порядка описания преобразования. Поскольку они часто находятся в разных исходных файлах (написанных разными людьми), смысл программы будет зависеть от порядка компоновки этих частей вместе. Есть другой вариант – запретить все неявные преобразования. Нет ничего проще, но такое правило приведет либо к неэлегантным пользовательским интерфейсам, либо к бурному росту перегруженных функций, как это было в предыдущем разделе с complex.

Самый общий подход учитывал бы всю имеющуюся информацию о типах и рассматривал бы все возможные преобразования. Например, если использовать предыдущее описание, то можно было бы обработать aa=f(1), так как тип aa определяет единственность толкования. Если aa является x, то единственное, дающее в результате x, который требуется присваиванием, – это f(x(1)), а если aa – это y, то вместо этого будет использоваться f(y(1)). Самый общий подход справился бы и с g(“asdf”), поскольку единственной интерпретацией этого может быть g(z(x(“asdf”))). Сложность этого подхода в том, что он требует расширенного анализа всего выражения для того, чтобы определить интерпретацию каждой операции и вызова функции. Это приведет к замедлению компиляции, а также к вызывающим удивление интерпретациям и сообщениям об ошибках, если компилятор рассмотрит преобразования, определенные в библиотеках и т. п. При таком подходе компилятор будет принимать во внимание больше, чем, как можно ожидать, знает пишущий программу программист!


Определяемое Преобразование Типа