Язык программирования C++. Пятое издание - Стенли Липпман

binops["+"](10, 5); // вызов add(10, 5)

binops["-"](10, 5); // использует оператор; вызов объекта minus<int>

binops["/"](10, 5); // использует оператор; вызов объекта div

binops["*"](10, 5); // вызов объекта лямбда-функции

binops["%"](10, 5); // вызов объекта лямбда-функции

Здесь происходит вызов каждой из операций, хранимых в карте binops. В первом вызове возвращаемый элемент является указателем на функцию, указывающим на функцию add(). Вызов binops["+"](10, 5) использует этот указатель для вызова функции add с передачей ей значений 10 и 5. Следующий вызов, binops["-"], возвращает объект класса function, хранящий объект типа std::minus<int>. Затем можно вызвать оператор этого объекта и других.

Перегруженные функции и тип function

Нельзя непосредственно хранить имя перегруженной функции в объекте типа function:

int add(int i, int j) { return i + j; }

Sales_data add(const Sales_data&, const Sales_data&);

map<string, function<int(int, int)>> binops;

binops.insert({"+", add}); // ошибка: какой именно add?

Один из способов разрешения двусмысленности подразумевает хранение указателя на функцию (см. раздел 6.7) вместо имени функции:

int (*fp)(int, int) = add; // указатель на версию add,

                           // получающую два int

binops.insert({"+", fp});  // ok: fp указывает на правую версию add

В качестве альтернативы для устранения неоднозначности можно использовать лямбда-выражение:

// ok: использование лямбда-выражения

// для устранения неоднозначности при

// выборе используемой версии add

binops.insert({"+", [](int a, int b) {return add(a, b);} });

Вызов в теле лямбда-выражения передает два целых числа. Этому вызову может соответствовать только та версия функции add(), которая получает два целых числа, а следовательно, эта функция и применяется при выполнении лямбда-выражения.

Класс function в новой библиотеке никак не связан с классами unary_function и binary_function, которые были частью прежних версий библиотеки. Эти классы были заменены более общей функцией bind() (см. раздел 10.3.4).

Упражнения раздела 14.8.3

Упражнение 14.44. Напишите собственную версию простого калькулятора, способного выполнять бинарные операции.

14.9. Перегрузка, преобразование и операторы

В разделе 7.5.4 упоминалось, что неявный конструктор, который может быть вызван с одним аргументом, определяет неявное преобразование. Такие конструкторы преобразовывают объект типа аргумента в тип класса. Можно также определить преобразование из типа класса. Для этого нужно определить оператор преобразования. Конструкторы преобразования и операторы преобразования определяют преобразования типа класса (class-type conversion). Такие преобразования называются также пользовательскими преобразованиями (user-defined conversion).

14.9.1. Операторы преобразования

Оператор преобразования (conversion operator) — это специальный вид функции-члена класса. Общий синтаксис функции преобразования имеет следующий вид:

operator тип() const;

где тип — это имя типа. Операторы преобразования могут быть определены для любого типа (кроме void), который может быть типом возвращаемого значения функции (см. раздел 6.1). Преобразование в тип массива или функции недопустимо. Однако преобразование в тип указателя на данные или функцию, а также ссылочные типы вполне возможны.

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

Функция преобразования должна быть функцией-членом, у нее не определен тип возвращаемого значения и пустой список параметров. Функция обычно должна быть константой.

Определение класса с оператором преобразования

Для примера определим небольшой класс, представляющий целое число в диапазоне от 0 до 255:

class SmallInt {

public:

 SmallInt(int i = 0): val(i) {

  if (i < 0 || i > 255)

   throw std::out_of_range("Bad SmallInt value");

 }

 operator int() const { return val; }

private:

 std::size_t val;

};

Класс SmallInt определяет преобразования в и из своего типа. Конструктор преобразует значения арифметического типа в тип SmallInt. Оператор преобразования преобразует объекты класса SmallInt в тип int:

SmallInt si;

si = 4; // неявно преобразует 4 в SmallInt, а затем

        // вызывает SmallInt::operator=

si + 3; // неявно преобразует si в int с последующим целочисленным

        // суммированием

Хотя компилятор применяет только одно пользовательское преобразование за раз (см. раздел 4.11.2), неявное пользовательское преобразование можно предварить или сопроводить стандартным (встроенным) преобразованием (см. раздел 4.11.1). В результате конструктору SmallInt можно передать любой арифметический тип. Точно так же можно использовать оператор преобразования для преобразования объекта класса SmallInt в int, а затем преобразовать полученное значение типа int в другой арифметический тип:

// аргумент типа double преобразуется в int с использованием

// встроенного преобразования

SmallInt si = 3.14; // вызов конструктора SmallInt(int)

// оператор преобразования класса SmallInt преобразует si в int

si + 3.14; // int преобразуется в double с использованием встроенного

           // преобразования

Поскольку операторы преобразования применяются неявно, нет никакого способа передать аргументы этим функциям. Следовательно, операторы преобразования не могут быть определены как получающие параметры. Хотя функция преобразования не определяет тип возвращаемого значения, каждая из них должна возвратить значение соответствующего типа:

class SmallInt;

operator int(SmallInt&); // ошибка: не член класса

class SmallInt {

public:

 int operator int() const; // ошибка: тип возвращаемого значения

 operator int(int = 0) const;         // ошибка: список параметров

 operator int*() const { return 42; } // ошибка: 42 не указатель

};

Внимание! Не злоупотребляйте функциями преобразования

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

Для примера рассмотрим класс Date, представляющий данные о дате. Вполне очевидно, что имеет смысл предоставить способ преобразования объекта класса Date в объект типа int. Но какое значение должна возвращать функция преобразования? Она могла бы возвратить десятичное представление года, месяца и дня. Например, 30 июля 1989 года могло бы быть представлено как значение 19800730 типа int. В качестве альтернативы оператор преобразования мог бы возвращать целое число, соответствующее количеству дней, начиная с некоторой эпохальной даты. Счетчик мог бы считать дни с 1 января 1970 года или некой другой отправной точки. У обоих преобразований есть желаемое свойство, что более поздние даты соответствуют большим целым числам, что может быть очень полезно.

Проблема в том, что нет единого и полного соответствия между объектом типа Date и значением типа int. В таких случаях лучше не определять оператор преобразования. Вместо него класс должен определить один или несколько обычных членов, чтобы извлекать эту информацию в различных форматах.

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

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