C++ - Страустрап Бьярн

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;

Действие ввода cin»»x выше возвращает istream amp;. Это знчение неявно преобразуется к значению, которое указывает сотояние cin, а уже это значение может проверяться оператором while (см. #8.4.2). Однако определять преобразование из оного типа в другой так, что при этом теряется информация, обычно не стоит.

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

Присваивание объекту (или инициализация объекта) класса 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)), и был бы недопустим по правилу единственности. Но первая интерпретация использует только стандартное преобразование и она будет выбрана по правилам, приведенным в #4.6.7.

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

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

6.4 Константы

Константы классового типа определить невозможно в том смысле, в каком 1.2 и 12e являются константами типа double. Вместо них, однако, часто можно использовать константы осноных типов, если их реализация обеспечивается с помощью фунций членов. Общий аппарат для этого дают конструкторы, полчающие один параметр. Когда конструкторы просты и подставляются inline, имеет смысл рассмотреть в качестве константы вызов конструктора. Если, например, в «comlpex.h» есть описание класса comlpex, то выражение zz1*3+zz2*comlpex(1,2) даст два вызова функций, а не пять. К двум вызовам функций приведут две операции *, а операция + и конструктор, к которому обращаются для создания comlpex(3) и comlpex(1,2), будут расширены inline.

6.5 Большие объекты

При каждом применении для comlpex бинарных операций, описанных выше, в функцию, которая реализует операцию, как параметр передается копия каждого операнда. Расходы на копрование каждого double заметны, но с ними вполне можно примриться. К сожалению, не все классы имеют небольшое и удобное представление. Чтобы избежать ненужного копирования, можно описать функции таким образом, чтобы они получали ссылочные параметры. Например:

class matrix (* double m[4][4]; public: matrix(); friend matrix operator+(matrix amp;, matrix amp;); friend matrix operator*(matrix amp;, matrix amp;); *);

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

matrix operator+(matrix amp;, matrix amp;); (* matrix sum; for (int i=0; i«4; i++) for (int j=0; j«4; j++) sum.m[i][j] = arg1.m[i][j] + arg2.m[i][j]; return sum; *)

Эта operator+() обращается к операндам + через ссылки, но возвращает значение объекта. Возврат ссылки может оказатся более эффективным:

class matrix (* // ... friend matrix amp; operator+(matrix amp;, matrix amp;);

friend matrix amp; operator*(matrix amp;, matrix amp;); *);

Это является допустимым, но приводит к сложности с выдлением памяти. Поскольку ссылка на результат будет передваться из функции как ссылка на возвращаемое значение, оно не может быть автоматической переменной. Поскольку часто оперция используется в выражении больше одного раза, результат не может быть и статической переменной. Как правило, его размщают в свободной памяти. Часто копирование возвращаемого знчения оказывается дешевле (по времени выполнения, объему кода и объему данных) и проще программируется.

6.6 Присваивание и инициализация

Рассмотрим очень простой класс строк string:

struct string (* char* p; int size; // размер вектора, на который указывает p

string(int sz) (* p = new char[size=sz]; *) ~string() (* delete p; *) *);

Строка – это структура данных, состоящая из вектора сиволов и длины этого вектора. Вектор создается конструктором и уничтожается деструктором. Однако, как показано в #5.10, это может привести к неприятностям. Например: