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

В коде point->mem часть point должна быть указателем на объект класса или объектом класса с перегруженным оператором operator->. В зависимости от типа части point код point->mem может быть эквивалентен следующему:

(*point).mem;          // point - указатель встроенного типа

point.operator()->mem; // point - объект типа класса

В противном случае код ошибочен. Таким образом, код point->mem выполняется следующим образом.

1. Если point — указатель, то применение встроенного оператора стрелки означает эквивалент выражения (*point).mem. Указатель обращается к значению члена класса и выбирает его из объекта. Если у типа, на объект которого указывает point, нет члена по имени mem, то этот код ошибочен.

2. Если point — объект класса, в котором определен оператор operator->, то результат вызова point.operator->() используется для выбора члена mem. Если результат является указателем, то для него выполняется этап 1. Если результат является объектом, класс которого сам обладает перегруженным оператором operator->(), то с этим объектом повторяется данный этап. Процесс продолжается до тех пор, пока не будет возвращен указатель на объект с означенным членом или некое другое значение, означающее ошибочность кода.

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

Упражнение 14.30. Добавьте операторы обращения к значению и стрелки в класс StrBlobPtr и класс ConstStrBlobPtr из упражнения 12.22 раздела 12.1.6. Обратите внимание, что операторы класса ConstStrBlobPtr должны возвращать константные ссылки, поскольку переменная-член data класса ConstStrBlobPtr указывает на константный вектор.

Упражнение 14.31. В классе StrBlobPtr не определен конструктор копий, оператор присвоения и деструктор. Почему?

Упражнение 14.32. Определите класс, содержащий указатель на класс StrBlobPtr. Определите перегруженный оператор стрелки для этого класса.

14.8. Оператор вызова функции

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

В качестве простого примера рассмотрим структуру absInt, обладающую оператором вызова, возвращающим абсолютное значение своего аргумента:

struct absInt {

 int operator()(int val) const {

  return val < 0 ? -val : val;

 }

};

Этот класс определяет одну функцию: оператор вызова функции. Этот оператор получает аргумент типа int и возвращает абсолютное значение аргумента.

Оператор вызова используется применительно к списку аргументов объекта класса absInt способом, который выглядит как вызов функции:

int i = -42;

absInt absObj;      // объект класса с оператором вызова функции

int ui = absObj(i); // передача i в absObj.operator()

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

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

Объект класса, определяющего оператор вызова, называется объектом функции (function object). Такие объекты действуют как функции, поскольку их можно вызвать.

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

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

class PrintString {

public:

 PrintString(ostream &o = cout, char c = ' '):

  os(o), sep(c) { }

 void operator()(const string &s) const { os << s << sep; }

private:

 ostream &os; // поток для записи

 char sep;    // символ завершения после каждого вывода

};

У класса есть конструктор, получающий ссылку на поток вывода, и символ, используемый как разделитель. Как аргументы по умолчанию (см. раздел 6.5.1) для этих параметров используется поток cout и пробел. Тело оператора вызова функции использует эти члены при выводе данной строки.

При определении объектов класса PrintString можно использовать аргументы по умолчанию или предоставлять собственные значения для разделителя или потока вывода:

PrintString printer; // использует аргументы по умолчанию; вывод в cout

printer(s);          // выводит s и пробел в cout

PrintString errors(cerr, 'n');

errors(s);           // выводит s и новую строку в cerr

Объекты функции обычно используют как аргументы для обобщенных алгоритмов. Например, для вывода содержимого контейнера можно использовать класс PrintString и библиотечный алгоритм for_each() (см. раздел 10.3.2):

for_each(vs.begin(), vs.end(), PrintString(cerr, 'n'));

Третий аргумент алгоритма for_each() является временным объектом типа PrintString, инициализируемый потоком cerr и символом новой строки. Вызов функции for_each() выводит каждый элемент vs в поток cerr, разделяя их новой строкой.

Упражнение 14.33. Сколько операндов может иметь перегруженный оператор вызова функции?

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

Упражнение 14.35. Напишите класс, подобный классу PrintString, который читает строку из потока istream и возвращает строку, представляющую прочитанное. При неудаче чтения следует возвратить пустую строку.

Упражнение 14.36. Используя класс из предыдущего упражнения, организуйте чтение со стандартного устройства ввода, сохраняя каждую строку в векторе как элемент.

Упражнение 14.37. Напишите класс, проверяющий равенство двух значений. Используйте этот объект и библиотечные алгоритмы для написания кода замены всех экземпляров заданного значения в последовательности.

14.8.1. Лямбда-выражения — объекты функции

В предыдущем разделе объект PrintString использовался как аргумент в вызове функции for_each(). Это похоже на программу, написанную в разделе 10.3.2, где использовалось лямбда-выражение. Написанное лямбда-выражение компилятор преобразовывает в безымянный объект безымянного класса (см. раздел 10.3.3). Классы, созданные из лямбда-выражения, содержат перегруженный оператор вызова функции. Рассмотрим, например, лямбда-выражение, передававшееся как последний аргумент функции stable_sort():

// сортировать слова по размеру, поддерживая алфавитный порядок среди

// слов того же размера

stable_sort(words.begin(), words.end(),

            [](const string &a, const string &b)

             { return a.size() < b.size();});

Это действует как безымянный объект класса, который выглядел бы примерно так:

class ShorterString {

public:

 bool operator()(const string &s1, const string &s2) const

  { return s1.size() < s2.size(); }

};

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

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