Функциональное программирование на языке C++ [Иван Чукич] (pdf) читать онлайн

Функциональное программирование

Функциональное программирование

Хорошо написанный код легче тестировать и использовать повторно, его
проще распараллелить, и он меньше подвержен ошибкам. Владение приемами
функционального программирования поможет вам писать код, соответствующий
требованиям к современным приложениям, проще выражать сложную логику
программ, изящно обрабатывать ошибки и элегантно оформлять параллельные
алгоритмы. Язык C++ поддерживает функциональное программирование
с использованием шаблонов, лямбда-выражений и других своих базовых
возможностей, а также алгоритмов из библиотеки STL.
В этой книге вы найдете десятки примеров, диаграмм и иллюстраций,
описывающих идеи функционального программирования, которые вы сможете
применять в C++, включая ленивые вычисления, объекты-функции и вызываемые
объекты, алгебраические типы данных и многое другое.
Что внутри:
• как писать безопасный код без ущерба для производительности;
• явная обработка ошибок через систему типов;
• добавление в C++ новых управляющих структур;
• решение задач с использованием предметно-ориентированных языков (DSL).
Иван Чукич – один из основных разработчиков KDE; программирует
на C++ с 1998 года. Преподает курс современного C++ и функционального
программирования на факультете математики в Белградском университете.
«Книга предлагает читателям новый способ создания качественного
программного обеспечения и новый способ мышления».
Джан Лоренцо Меокки, CommProve
«Это издание особенно ценно для разработчиков на C++ среднего
и выше среднего уровня, желающих научиться писать программы
в реактивном стиле».
Марко Массенцио, Apple

Книга предназначена для опытных разработчиков на C++.
ISBN 978-5-97060-781-7

Интернетмагазин:
www.dmkpress.ru
Оптовая продажа:
КТК «Галактика»
email: books@alians-kniga.ru

www.дмк.рф

9 785970 607817

Функциональное программирование на С++

Как улучшить свои программы с помощью
приемов функционального программирования

Иван Чукич

Функциональное
программирование

на С++

Иван Чукич

Функциональное
программирование
на языке C++

Functional Programming
in C++
How to improve your C++ programs
using functional techniques

IVAN ČUKIĆ

Функциональное
программирование
на языке C++
Как сделать свои программы изящными
с помощью технологии функционального программирования

ИВАН ЧУКИЧ

Москва, 2020

УДК 004.4
ББК 32.973.202
Ч88

Ч88

Чукич И.
Функциональное программирование на языке C++ / пер. с англ. В. Ю. Винника, А. Н. Киселева. – М.: ДМК Пресс, 2020. – 360 с.: ил.
ISBN 978-5-97060-781-7
Язык С++ обычно ассоциируется с объектно-ориентированным программированием. Автор книги доказывает, что на С++ так же удобно создавать программы
и в функциональном стиле. Это дает ряд преимуществ, повышая удобство кода
и снижая вероятность возникновения ошибок.
Книга разделена на две части. В первой читатель знакомится с азами функционального программирования: основными идиомами и способами их воплощения
в языке C++. Вторая часть затрагивает более сложные аспекты и посвящена собственно
разработке программ с использованием функционального подхода.
Издание предназначено для опытных разработчиков на С++, желающих расширить
границы использования этого языка и повысить эффективность работы.

УДК 004.4
ББК 32.973.202

Original English language edition published by Manning Publications USA, USA. Copyright © 2019
by Manning Publications Co. Russian-language edition copyright © 2020 by DMK Press. All rights
reserved.
Все права защищены. Любая часть этой книги не может быть воспроизведена в какой
бы то ни было форме и какими бы то ни было средствами без письменного разрешения владельцев авторских прав.

ISBN 978-1-617-29381-8 (англ.)
ISBN 978-5-97060-781-7 (рус.)

Copyright © 2019 by Manning Publications Co.
© Оформление, издание, перевод, ДМК Пресс, 2020

Оглавление
1
2
3
4
5
6
7
8
9
10
11
12
13















Введение в функциональное программирование................................22
Первые шаги в функциональном программировании.........................47
Функциональные объекты......................................................................75
Средства создания новых функций из имеющихся............................ 107
Чистота функций: как избежать изменяемого состояния.................. 141
Ленивые вычисления............................................................................ 167
Диапазоны............................................................................................. 191
Функциональные структуры данных................................................... 209
Алгебраические типы данных и сопоставление с образцом.............. 226
Монады................................................................................................... 254
Метапрограммирование на шаблонах................................................. 284
Функциональный дизайн параллельных систем................................ 309
Тестирование и отладка........................................................................ 338

Содержание
Предисловие..........................................................................................................12
Благодарности.....................................................................................................14
Об этой книге.......................................................................................................15
Об авторе.............................................................................................................21

1

Введение в функциональное программирование............22
1.1

1.2
1.3
1.4

1.5

Что такое функциональное программирование.....................23
1.1.1

Соотношение функционального программирования
с объектно-ориентированным...............................................25
1.1.2 Сравнение императивной и декларативной парадигм
на конкретном примере.........................................................25
Чистые функции.............................................................................31
1.2.1 Устранение изменяемого состояния......................................34
Функциональный стиль мышления...........................................36
Преимущества функционального программирования.........38
1.4.1 Краткость и удобочитаемость кода.....................................39
1.4.2 Параллельная обработка и синхронизация............................41
1.4.3 Непрерывная оптимизация....................................................42

Эволюция C++ как языка функционального
программирования........................................................................42
1.6 Что узнает читатель из этой книги............................................44
Итоги...........................................................................................................45

2

Первые шаги в функциональном
программировании. .........................................................................47
2.1
2.2

Функции с аргументами-функциями........................................48
Примеры из библиотеки STL.......................................................50

2.2.1

Вычисление средних.................................................................51

Содержание

7

Свертки...................................................................................53
Удаление лишних пробелов......................................................58
Разделение коллекции по предикату.......................................60
Фильтрация и преобразование...............................................62
2.3 Проблема композиции алгоритмов из библиотеки STL.......64
2.4 Создание своих функций высшего порядка............................66
2.4.1 Передача функции в качестве аргумента..............................66
2.4.2 Реализация на основе циклов..................................................67
2.4.3 Рекурсия и оптимизация хвостового вызова.........................68
2.4.4 Реализация на основе свертки................................................72
Итоги...........................................................................................................74
2.2.2
2.2.3
2.2.4
2.2.5

3

Функциональные объекты...........................................................75
3.1

3.2

3.3

3.4

Функции и функциональные объекты......................................76

Автоматический вывод возвращаемого типа.......................76
Указатели на функции............................................................80
Перегрузка операции вызова...................................................81
Обобщенные функциональные объекты..................................84
Лямбда-выражения и замыкания. .............................................86
3.2.1 Синтаксис лямбда-выражений...............................................88
3.2.2 Что находится у лямбда-выражений «под капотом»............89
3.2.3 Создание лямбда-выражений с произвольными
переменными-членами............................................................92
3.2.4 Обобщенные лямбда-выражения............................................94
Как сделать функциональные объекты еще лаконичнее......95
3.3.1 Объекты-обертки над операциями в стандартной
библиотеке..............................................................................98
3.3.2 Объекты-обертки над операциями в сторонних
библиотеках.......................................................................... 100
3.1.1
3.1.2
3.1.3
3.1.4

Обертка над функциональными объектами – класс
std::function................................................................................... 103
Итоги......................................................................................................... 105

4

Средства создания новых функций из имеющихся..... 107
4.1

4.2

Частичное применение функций............................................. 108

4.1.1

Универсальный механизм превращения бинарных
функций в унарные................................................................ 110
4.1.2 Использование функции std::bind для фиксации значений
некоторых аргументов функции.......................................... 114
4.1.3 Перестановка аргументов бинарной функции.................... 116
4.1.4 Использование функции std::bind с функциями большего
числа аргументов.................................................................. 118
4.1.5 Использование лямбда-выражений вместо функции
std::bind................................................................................. 121
Карринг – необычный взгляд на функции............................. 124

Содержание

8

Простой способ создавать каррированные функции........... 125
Использование карринга для доступа к базе данных............ 127
Карринг и частичное применение функций.......................... 130
4.3 Композиция функций................................................................. 132
4.4 Повторное знакомство с подъемом функций....................... 136
4.4.1 Переворачивание пар – элементов списка........................... 138
Итоги......................................................................................................... 140
4.2.1
4.2.2
4.2.3

5

Чистота функций: как избежать изменяемого
состояния............................................................................................ 141
5.1
5.2
5.3
5.4
5.5

Проблемы изменяемого состояния. ........................................ 142
Чистые функции и референциальная прозрачность........... 145
Программирование без побочных эффектов........................ 148
Изменяемые и неизменяемые состояния
в параллельных системах........................................................... 152
О важности констант................................................................... 156

Логическая и внутренняя константность........................... 159
Оптимизированные функции-члены для временных
объектов................................................................................ 161
5.5.3 Недостатки константных объектов.................................. 163
Итоги......................................................................................................... 165

6

5.5.1
5.5.2

Ленивые вычисления...................................................................... 167
6.1
6.2

Ленивые вычисления в языке C++. .......................................... 168
Ленивые вычисления как средство оптимизации
программ. ...................................................................................... 172

Ленивая сортировка коллекций............................................ 172
Отображение элементов в пользовательском
интерфейсе........................................................................... 174
6.2.3 Подрезка дерева рекурсивных вызовов за счет
запоминания результатов функции..................................... 175
6.2.4 Метод динамического программирования
как разновидность ленивого вычисления.............................. 178
6.3 Универсальная мемоизирующая обертка.............................. 180
6.4 Шаблоны выражений и ленивая конкатенация строк......... 184
6.4.1 Чистота функций и шаблоны выражений............................ 188
Итоги......................................................................................................... 190
6.2.1
6.2.2

7

Диапазоны........................................................................................... 191
7.1
7.2

Введение в диапазоны................................................................ 193
Создание представлений данных, доступных только
для чтения. .................................................................................... 194

7.2.1

Функция filter для диапазонов............................................... 194

Содержание

7.3
7.4

7.5

9

Функция transform для диапазонов....................................... 196
Ленивые вычисления с диапазоном значений........................ 197
Изменение значений с помощью диапазонов...................... 199
Ограниченные и бесконечные диапазоны............................. 201
7.4.1 Использование ограниченных диапазонов
для оптимизации обработки входных диапазонов.............. 201
7.4.2 Создание бесконечного диапазона с помощью
ограничителя........................................................................ 203

7.2.2
7.2.3

Использование диапазонов для вычисления частоты
слов.................................................................................................. 204
Итоги......................................................................................................... 208

8

Функциональные структуры данных................................. 209

9

Алгебраические типы данных и сопоставление
с образцом........................................................................................... 226

8.1

Неизменяемые связанные списки........................................... 210

Добавление и удаление элемента в начале списка............... 210
Добавление и удаление элемента в конце списка................. 212
Добавление и удаление элемента в середине списка............ 213
Управление памятью............................................................ 213
8.2 Неизменяемые векторы............................................................. 216
8.2.1 Поиск элементов в префиксном дереве................................ 218
8.2.2 Добавление элементов в конец префиксного дерева............ 220
8.2.3 Изменение элементов в префиксном дереве......................... 223
8.2.4 Удаление элемента из конца префиксного дерева................ 223
8.2.5 Другие операции и общая эффективность
префиксных деревьев........................................................................ 223
Итоги......................................................................................................... 225

9.1

9.2

9.3
9.4

8.1.1
8.1.2
8.1.3
8.1.4

Алгебраические типы данных................................................... 227

9.1.1
9.1.2

9.1.3
9.1.4
9.1.5

Определение типов-сумм через наследование..................... 229
Определение типов-сумм с использованием
объединений и std::variant..................................................... 232
Реализация конкретных состояний...................................... 235
Особый тип-сумма: необязательные значения................... 237
Типы-суммы для обработки ошибок.................................... 240

Моделирование предметной области
с алгебраическими типами........................................................ 245

Простейшее решение............................................................ 246
Более сложное решение: проектирование сверху вниз......... 247
Алгебраические типы и сопоставление с образцом............ 248
9.2.1
9.2.2

Сопоставление с образцом с помощью библиотеки
Mach7.............................................................................................. 251
Итоги......................................................................................................... 253

Содержание

10

10

Монады.................................................................................................. 254

11

Метапрограммирование на шаблонах.............................. 284

10.1 Функторы....................................................................................... 255

10.1.1 Обработка необязательных значений................................. 256
10.2 Монады: расширение возможностей функторов................. 259
10.3 Простые примеры........................................................................ 262
10.4 Генераторы диапазонов и монад. ............................................ 265
10.5 Обработка ошибок....................................................................... 268
10.5.1 std::optional как монада.................................................. 268
10.5.2 expected как монада..................................................... 270
10.5.3 Исключения и монады........................................................... 271
10.6 Обработка состояния с помощью монад................................ 273
10.7 Монады, продолжения и конкурентное выполнение.......... 275
10.7.1 Тип future как монада............................................................ 277
10.7.2 Реализация типа future......................................................... 279
10.8 Композиция монад...................................................................... 281
Итоги......................................................................................................... 283

11.1 Манипулирование типами во время компиляции............... 285

11.1.1 Проверка правильности определения типа......................... 288
11.1.2 Сопоставление с образцом во время компиляции................ 290
11.1.3 Получение метаинформации о типах.................................. 293
11.2 Проверка свойств типа во время компиляции. .................... 294
11.3 Каррирование функций.............................................................. 296
11.3.1 Вызов всех вызываемых объектов......................................... 299

11.4 Строительные блоки предметно-ориентированного
языка............................................................................................... 302
Итоги......................................................................................................... 307

12

Функциональный дизайн параллельных систем.......... 309
12.1 Модель акторов: мышление в терминах компонентов....... 310
12.2 Простой источник сообщений.................................................. 314
12.3 Моделирование реактивных потоков данных в виде
монад.............................................................................................. 318

Создание приемника для сообщений..................................... 319
Преобразование реактивных потоков данных..................... 323
Создание потока заданных значений................................... 325
Объединение потоков в один поток..................................... 326
12.4 Фильтрация реактивных потоков............................................ 327
12.5 Обработка ошибок в реактивных потоках............................. 328
12.6 Возврат ответа клиенту.............................................................. 331
12.7 Создание акторов с изменяемым состоянием...................... 335
12.8 Распределенные системы на основе акторов........................ 336
Итоги......................................................................................................... 337
12.3.1
12.3.2
12.3.3
12.3.4

Содержание

13

11

Тестирование и отладка............................................................ 338
13.1 Программа, которая компилируется, – правильная?.......... 339
13.2 Модульное тестирование и чистые функции........................ 341
13.3 Автоматическое генерирование тестов.................................. 343

13.3.1 Генерирование тестовых случаев......................................... 343
13.3.2 Тестирование на основе свойств.......................................... 345
13.3.3 Сравнительное тестирование............................................. 347
13.4 Тестирование параллельных систем на основе монад. ...... 348
Итоги......................................................................................................... 352

Предметный указатель. .................................................................................. 353

Предисловие
Программирование – одна из тех немногих дисциплин, что позволяют
творить нечто буквально из ничего. Программист может творить целые
миры, которые ведут себя в точности как задумал автор. Для этого нужен
лишь компьютер.
Когда я учился в школе, курс программирования был в основном сфокусирован на императивном программировании – сначала это было
процедурное программирование на языке C, затем объектно-ориентированное на языках C++ и Java. С поступлением в университет почти
ничего не изменилось – основной парадигмой по-прежнему оставалось
объектно-ориентированное программирование (ООП).
Поэтому тогда я едва не попался в мыслительную ловушку, убедив
себя в том, что все языки программирования, в сущности, одинаковы,
различия между ними – чисто синтаксические и программисту довольно
изучить такие основополагающие понятия, как ветвление и цикл, в одном языке, чтобы программировать (с небольшими поправками) на всех
остальных языках.
С языками функционального программирования я впервые познакомился в университете, когда в рамках одной из дисциплин понадобилось
изучить язык LISP. Моей первой реакцией было смоделировать средствами языка LISP условный оператор if-then-else и оператор цикла for,
чтобы сделать язык пригодным для работы. Вместо того чтобы привести
свое восприятие в соответствие с языком, я решил доработать язык напильником, чтобы он позволял мне и дальше писать программы таким
же образом, каким я привык писать на языке C. Нетрудно догадаться, что
в те дни я не увидел никакого смысла в функциональном программировании, ведь все, чего я мог добиться, используя LISP, можно было гораздо
проще сделать на языке C.
Прошло немало времени, прежде чем я снова стал поглядывать в сторону функционального программирования. Подтолкнула меня к этому
неудовлетворенность слишком медленной эволюцией одного языка,
который мне необходимо было использовать для нескольких проектов.
В язык наконец добавили оператор цикла for-each, и это подавалось как
громадное достижение. Программисту оставалось лишь загрузить новый
компилятор, и жизнь должна была заиграть новыми красками.
Это заставило меня задуматься. Чтобы получить в свое распоряжение новую языковую конструкцию наподобие цикла for-each, мне нужно
было дождаться новой версии языка и новой версии компилятора. Но на
языке LISP я мог самостоятельно реализовать цикл for в виде обыкновенной функции. Никакого обновления компилятора при этом не требовалось.

Предисловие

13

Именно это склонило меня к функциональному программированию:
возможность расширять язык без необходимости менять компилятор.
Я по-прежнему оставался в плену объектно-ориентированного мировоззрения, но уже научился использовать конструкции, заимствованные из
функционального стиля, чтобы упростить работу по созданию объектноориентированного кода.
Тогда я стал посвящать много времени исследованию функциональных языков программирования, таких как Haskell, Scala и Erlang. Меня
поразило, что многие проблемы, заставляющие страдать объектно-ориентированных программистов, удается легко решить, посмотрев на них
под другим углом – функциональным.
Поскольку большая часть моей работы связана с языком C++, я решил
найти способ, как использовать в этом языке приемы функционального программирования. Оказалось, что я в этом не одинок: в мире полно
других людей с похожими идеями. Некоторых из них мне посчастливилось встретить на различных конференциях по языку C++. Всякий раз это
была превосходная возможность обменяться идеями, научиться чему-то
новому и поделиться своим опытом применения идиом функционального программирования на языке C++.
На большей части таких встреч мы с коллегами сходились на том, что
было бы замечательно, если бы кто-то написал книгу о функциональном
программировании на C++. Вот только каждый из нас хотел, чтобы эту
книгу написал кто-то другой, поскольку каждый искал источник готовых
идей, пригодных для собственных проектов.
Когда издательство Manning предложило мне стать автором такой
книги, это меня поначалу обескуражило: я считал, что мне следовало бы
прочесть об этом книгу, а не написать ее. Однако затем я подумал, что
если каждый будет рассуждать подобным образом, никто так и не увидит книгу о функциональном программировании на языке C++. Я решил
принять предложение и отправиться в это путешествие. То, что из этого
получилось, вы сейчас и читаете.

Благодарности
Я хотел бы поблагодарить всех, чье участие сделало эту книгу возможной: профессора Сашу Малкова за то, что привил мне любовь к языку C++; Ако Самарджича за то, что научил меня, насколько важно писать
легкочитаемый код; моего друга Николу Йелича, который убедил меня,
что функциональное программирование – это здорово; Золтана Порколаба, поддержавшего мою догадку, что функциональное программирование и язык C++ образуют хорошую смесь; Мирьяну Малькович за помощь в обучении наших студентов тонкостям современного языка C++,
включая и элементы функционального программирования.
Почет и уважение Сергею Платонову и Йенсу Веллеру за организацию
превосходных конференций по языку C++ для тех из нас, кто все еще живет старыми традициями. Можно смело сказать, что без всех перечисленных людей эта книга бы не состоялась.
Я хотел бы поблагодарить своих родителей, сестру Соню и свою вторую половинку Милицу за то, что всегда поддерживали меня в смелых
начинаниях наподобие этого. Кроме того, я благодарен своим давним
товарищам по проекту KDE, которые помогли мне вырасти как разработчику за прошедшее десятилетие, – прежде всего Марко Мартину, Аарону
Сеиго и Себастиану Кюглеру.
Огромная благодарность команде редакторов, которую для меня организовало издательство Manning: Майклу (или просто Майку) Стивенсу
за самое непринужденное из всех моих собеседований; замечательным
ответственным редакторам Марине Майклс и Лесли Трайтс, которые научили меня писать книгу (благодаря им я научился гораздо большему,
чем мог ожидать); техническому редактору Марку Эльстону за то, что заставлял меня держаться ближе к практике; блестящему Юнвэю Ву, который не только проделал работу по вычитке книги, но и помог улучшить
рукопись множеством различных способов. Надеюсь, что доставил всем
им не слишком много хлопот.
Также выражаю свою признательность всем, кто предоставил свой
отзыв на рукопись: Андреасу Шабусу, Биннуру Курту, Дэвиду Кернсу,
Димитрису Пападопулосу, Дрору Хелперу, Фредерику Флейолю, Георгу
Эрхардту, Джанлуиджи Спануоло, Глену Сиракавиту, Жану Франсуа Морену, Керти Шетти, Марко Массенцио, Нику Гидео, Никосу Атанасиу, Нитину Годе, Ольве Маудалю, Патрику Регану, Шону Липпи, а в особенности Тимоти Театро, Ади Шавиту, Суманту Тамбе, Джану Лоренцо Меоччи
и Николе Гиганте.

Об этой книге
Эта книга предназначена не для того, чтобы научить читателя языку
программирования C++. Она повествует о функциональном программировании и о том, как воплотить его в языке C++. Функциональное
программирование предлагает непривычный взгляд на разработку программ и иной подход к программированию, по сравнению с императивным и объектно-ориентированным стилем, который обычно используется совместно с языком C++.
Многие, увидев заглавие этой книги, могут счесть его странным, поскольку C++ часто по ошибке принимают за объектно-ориентированный
язык. Однако хотя язык C++ и впрямь хорошо поддерживает объектноориентированную парадигму, он на самом деле выходит далеко за ее
границы. Так, он поддерживает еще и процедурную парадигму, а в поддержке обобщенного программирования большинству других языков
с ним не сравниться. Кроме того, язык C++ весьма хорошо поддерживает
большинство, если не все, из идиом функционального программирования, в чем читатель сможет вскоре убедиться. С каждой новой версией
язык C++ пополнялся новыми средствами, делающими функциональное
программирование на нем все более удобным.

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

Последовательность чтения
Данную книгу лучше всего читать последовательно, так как каждая последующая глава опирается на понятия, разобранные в предыдущих.
Если что-либо остается непонятным после первого прочтения, лучше
перечитать сложный раздел еще раз, прежде чем двигаться дальше, по-

16

Об этой книге

скольку сложность материала возрастает с каждой главой. Единственное
исключение здесь составляет глава 8, которую читатель может пропус­
тить, если не интересуется методами долговременного хранения структур данных.
Книга разделена на две части. Первая часть охватывает идиомы
функционального программирования и способы их воплощения в языке C++.
„„ Глава 1 вкратце знакомит читателя с функциональным программированием и преимуществами, которые оно может привнести
в мир C++.
„„ Глава 2 посвящена функциям высшего порядка – функциям, которые принимают другие функции в качестве аргументов или возвращают функции в качестве значений. Данное понятие иллюст­
рируется некоторыми из множества полезных функций высшего
порядка, включенных в стандартную библиотеку языка программирования C++.
„„ Глава 3 повествует обо всех разнообразных сущностях, которые
в языке C++ рассматриваются как функции, – от обычных функций
в смысле языка C до функциональных объектов и лямбда-функций.
„„ Глава 4 содержит изложение различных способов создания новых
функций из имеющихся. В этой главе рассказано о частичном применении функций с использованием операции std::bind и лямбдавыражений, а также представлен необычный взгляд на функции,
известный как карринг.
„„ В главе 5 говорится о важности неизменяемых данных, то есть объектов данных, которые невозможно модифицировать после создания. Здесь освещены проблемы, возникающие при наличии изменяемого состояния, и методы создания программ без присваивания
переменным новых значений.
„„ Глава 6 посвящена подробному разбору понятия ленивых вычислений. В ней показано, как ленивый порядок вычислений можно использовать для оптимизации, начиная с простых задач наподобие
конкатенации строк и до алгоритмов оптимизации, основанных на
методе динамического программирования.
„„ В главе 7 рассказано о диапазонах – современном дополнении к алгоритмам стандартной библиотеки, призванном повысить удобство
восприятия кода и его производительность.
„„ Глава 8 содержит изложение неизменяемых структур данных, т. е.
структур данных, которые хранят историю своих предыдущих состояний, пополняя ее при каждой модификации.
Во второй части книги речь пойдет о более сложных понятиях, по
большей части относящихся к разработке программ в функциональном
стиле.
„„ В главе 9 речь идет о том, как избавить программу от недопустимых состояний с помощью суммы типов. Показано, как реализовать
сумму типов на основе наследования и шаблона std::variant и как

Об этой книге

17

для их обработки использовать перегруженные функциональные
объекты.
„„ Глава 10 посвящена функторам и монадам – абстракциям, способным существенно помочь при работе с обобщенными типами
и, в частности, позволяющим создавать функции для работы с векторами, значениями типа optional и фьючерсами.
„„ В главе 11 содержится объяснение техник метапрограммирования
на шаблонах, способствующих функциональному программированию на языке C++. В частности, разобраны статическая интроспекция, вызываемые объекты и техники метапрограммирования на
шаблонах, предназначенные для создания встроенных предметноориентированных языков.
„„ В главе 12 весь предшествующий материал книги собран воедино,
чтобы продемонстрировать функциональный подход к разработке
параллельных программных систем. В этой главе рассказано, как
монаду продолжения можно применить для создания реактивных
программ.
„„ Глава 13 знакомит читателя с функциональным подходом к тестированию и отладке программ.
Автор советует читателю по мере чтения книги реализовывать все
изложенные в ней понятия и запускать все встречающиеся примеры
кода. Большую часть подходов, описанных в книге, можно использовать
и в старых версиях языка C++, однако это потребовало бы написания
большого объема дублирующегося кода; поэтому в книге упор сделан
главным образом на языковые стандарты C++14 и C++17.
Примеры кода созданы в предположении, что у читателя есть работающий компилятор с поддержкой стандарта C++17. Можно, например, пользоваться компилятором GCC, как автор этой книги, или Clang. Последние выпущенные версии обоих этих компиляторов одинаково хорошо
поддерживают все элементы стандарта C++17, использованные в данной
книге. Все примеры кода протестированы с версиями1 GCC 7.2 и Clang 5.0.
Для работы с примерами можно пользоваться обычным текстовым
редактором и запускать компилятор вручную из командной строки через посредство утилиты GNU make (к каждому примеру приложен несложный сценарий Makefile); также можно воспользоваться полновесной
интегрированной средой разработки наподобие QtCreator (www.qt.io),
Eclipse (www.eclipse.org), Kdevelop (www.kdevelop.org) или CLion (www.
jetbrains.com/clion) и импортировать в нее примеры. Тем, кто намерен
пользоваться средой Microsoft Visual Studio, рекомендуется установить
наиболее свежую версию, какую возможно загрузить, и настроить ее на
применение компилятора Clang вместо используемого по умолчанию
компилятора Microsoft Visual С++ (MSVC), которому на момент написания этого введения не хватало некоторых важных мелочей.
1

На момент перевода этого введения актуальны версии GCC 9.1 и Clang 8.0.0.
Качество поддержки стандарта C++17 более не должно составлять предмета
для беспокойства. – Прим. перев.

Об этой книге

18

Хотя для компиляции большей части примеров не нужны никакие
внешние зависимости, некоторым примерам все же нужны сторонние
библиотеки, такие как range-v3, catch и JSON, клоны которых доступны
вместе с кодом примеров в директории common/3rd-party, а также коллекция библиотек Boost, которую можно загрузить с сайта www.boost.org.

Оформление кода и загрузка примеров
Исходный код примеров к этой книге можно загрузить на сайте издательства по адресу www.manning.com/books/functional-programming-inc-plus-plus и с системы GitLab по адресу https://gitlab.com/manning-fpcpp-book.
В книге содержится много примеров исходного кода – как в виде нумерованных листингов, так и короткими вставками в обычный текст.
В обоих случаях код набран моноширинным шрифтом наподобие этого, чтобы его
легко было отличить от текста на естественном языке.
Во многих случаях первоначальный текст примеров пришлось видоизменить, добавив разрывы строк и отступы, чтобы улучшить размещение исходного кода на книжной странице. В редких случаях даже этого
оказалось недостаточно, и тогда в листинг пришлось ввести знаки продолжения строки . Кроме того, комментарии из исходного кода часто
удалялись, если этот код сопровождается подробными пояснениями
в основном тексте. Пояснения прилагаются ко многим листингам, помогая понять важные детали.
Спорить о стилях оформления исходного кода – превосходная возможность впустую потратить уйму времени. Это особенно характерно
для языка C++, где едва ли не каждый проект претендует на собственный
стиль.
Автор старался следовать соглашениям, используемым в ряде других
книг по языку C++. Два стилистических правила стоит оговорить здесь
особо:
„„ классы, моделирующие сущности из реального мира, например
людей или домашних животных, получают имена с суффиксом _t.
Благодаря этому становится проще понять в каждом конкретном
случае, идет речь о реальном объекте (например, человеке) или
о типе – имя person_t читается проще, чем «тип “человек”»;
„„ имена закрытых переменных-членов имеют приставку m_. Это отличает их от статических переменных-членов, чьи имена начинаются
с префикса s_.

Форум книги
Покупка этой книги дает бесплатный доступ к закрытому форуму, функционирующему под управлением издательства Manning Publications, где
читатели могут оставлять комментарии о книге, задавать технические
вопросы и получать помощь от автора и других пользователей. Чтобы

Об этой книге

19

получить доступ к форуму, нужно зайти на страницу https://forums.manning.com/forums/functional-programming-in-c-plus-plus. Больше о форумах издательства Manning и о принятых там правилах поведения можно
узнать на странице https://forums.manning.com/forums/about.
Издательство Manning берет на себя обязательство перед своими читателями обеспечить им удобную площадку для общения читателей как
между собой, так и с автором книги. Это, однако, не предполагает какого-либо определенного объема участия со стороны автора, чье общение
на форуме остается исключительно добровольным и неоплачиваемым.
Задавая автору интересные вопросы, читатели могут освежать и подогревать его интерес к теме книги. Форум и архивы предыдущих обсуждений будут доступны на сайте издательства все время, пока книга остается в продаже.

Отзывы и пожелания
Мы всегда рады отзывам наших читателей. Расскажите нам, что вы думаете об этой книге – что понравилось или, может быть, не понравилось.
Отзывы важны для нас, чтобы выпускать книги, которые будут для вас
максимально полезны.
Вы можете написать отзыв прямо на нашем сайте www.dmkpress.com,
зайдя на страницу книги, и оставить комментарий в разделе «Отзывы
и рецензии». Также можно послать письмо главному редактору по адресу
dmkpress@gmail.com, при этом напишите название книги в теме письма.
Если есть тема, в которой вы квалифицированы, и вы заинтересованы
в написании новой книги, заполните форму на нашем сайте по адресу
http://dmkpress.com/authors/publish_book/ или напишите в издательство
по адресу dmkpress@gmail.com.

Скачивание исходного кода примеров
Скачать файлы с дополнительной информацией для книг издательства
«ДМК Пресс» можно на сайте www.dmkpress.com или www.дмк.рф на
странице с описанием соответствующей книги.

Список опечаток
Хотя мы приняли все возможные меры для того, чтобы удостовериться
в качестве наших текстов, ошибки все равно случаются. Если вы найдете
ошибку в одной из наших книг – возможно, ошибку в тексте или в коде, –
мы будем очень благодарны, если вы сообщите нам о ней. Сделав это,
вы избавите других читателей от расстройств и поможете нам улучшить
последующие версии этой книги.
Если вы найдете какие-либо ошибки в коде, пожалуйста, сообщите
о них главному редактору по адресу dmkpress@gmail.com, и мы исправим это в следующих тиражах.

20

Об этой книге

Нарушение авторских прав
Пиратство в интернете по-прежнему остается насущной проблемой. Издательства «ДМК Пресс» и Manning очень серьезно относятся к вопросам
защиты авторских прав и лицензирования. Если вы столкнетесь в интернете с незаконно выполненной копией любой нашей книги, пожалуйста,
сообщите нам адрес копии или веб-сайта, чтобы мы могли применить
санкции.
Пожалуйста, свяжитесь с нами по адресу dmkpress@gmail.com со ссылкой на подозрительные материалы.
Мы высоко ценим любую помощь по защите наших авторов, помогающую нам предоставлять вам качественные материалы.

Об авторе
Иван Чукич преподает современные методы программирования на языке C++ и функциональное программирование
на факультете математики в Белграде. Он использует язык
C++ с 1998 г. Он исследовал функциональное программирование на языке C++ перед и во время подготовки своей
диссертации, а также применяет методы функционального
программирования в реальных проектах, которыми пользуются сотни миллионов человек по всему миру. Иван –
один из ключевых разработчиков среды KDE, крупнейшего
в мире проекта с открытым кодом на языке C++.

1

Введение в функциональное
программирование

О чем говорится в этой главе:

понятие о функциональном программировании;
рассуждение в терминах предназначения вместо шагов алгоритма;
„„ понятие о чистых функциях;
„„ преимущества функционального программирования;
„„ эволюция C++ в язык функционального программирования.
„„
„„

Каждому программисту приходится изучить за свою жизнь целый ряд
языков программирования. Как правило, программист останавливается
на двух или трех языках, на которых лично ему удобнее всего работать.
Часто можно услышать, что изучить очередной язык программирования
просто – что различия между языками в основном касаются лишь синтаксиса и что все языки предоставляют примерно одинаковые возможности. Тот, кто знает язык C++, наверняка легко выучит языки Java и C#,
и наоборот.
В этом утверждении есть доля истины. Однако, берясь за изучение нового языка, мы невольно пытаемся имитировать на нем тот стиль программирования, который выработался в связи с предыдущим языком.
Когда я впервые начал применять функциональный язык во время учебы в университете, то сразу начал с попыток определить на нем привычные операторы цикла for и while и оператор ветвления if-then-else.
Это именно тот подход, которым пользуется большинство из нас, чтобы
просто сдать экзамен и никогда больше не возвращаться к изученному.
Широко известен афоризм, что тот, у кого из инструментов есть лишь
молоток, будет стремиться любую задачу считать гвоздем. Этот прин-

Что такое функциональное программирование

23

цип работает и в обратную сторону: если работать только с гвоздями, то
любой попавший в руки инструмент будет использоваться как молоток.
Многие программисты, попробовав язык функционального программирования, решают, что он не стоит затраченных усилий; они не видят
в новом языке преимуществ, поскольку пытаются использовать этот новый инструмент таким же способом, как использовали бы старый.
Цель этой книги состоит не в том, чтобы научить читателя новому
языку программирования; вместо этого книга призвана научить иному
способу использования старого языка (а именно языка C++) – способу,
настолько отличному от привычного, что у программиста впрямь может
возникнуть ощущение, что он использует новый язык. Этот новый стиль
программирования помогает создавать более продуманные программы и писать более безопасный, понятный и читаемый код и даже – не
побоюсь сказать – более изящный, чем код, который обычно пишут на
языке C++.

1.1 Что такое функциональное
программирование
Функциональное программирование – это довольно старая парадигма,
зародившаяся в академической среде в конце 1950-х годов и долгое время остававшаяся в этой нише. Хотя эта парадигма всегда была излюб­
ленной темой для научных исследований, она никогда не пользовалась
популярностью в «реальном мире». Вместо этого повсеместное распространение получили императивные языки: сперва процедурные, затем
объектно-ориентированные.
Часто звучали предсказания, что однажды функциональные языки будут править миром, но этого до сих пор не произошло. Наиболее известные языки функционального программирования, такие как Haskell или
LISP, все еще не входят в десятку наиболее популярных языков. Первые
места по традиции прочно занимают императивные языки, к которым
относятся языки C, Java и C++. Это предсказание, подобно большинству
других, чтобы считаться сбывшимся, нуждается в известной свободе интерпретации. Вместо того чтобы популярность завоевали языки функционального программирования, произошло нечто иное: в популярные
языки программирования стали добавлять все более элементов, заимствованных из языков функционального программирования.
Что собой представляет функциональное программирование (ФП)?
На этот вопрос непросто ответить, так как не существует единого общепринятого определения. Согласно известному афоризму, если двух программистов, работающих в функциональном стиле, спросить, что такое
ФП, они дадут по меньшей мере три различных ответа. Каждый специа­
лист обычно старается определить ФП через другие связанные с ним
понятия: чистые функции, ленивые вычисления, сопоставление с образцом и другие – и обычно при этом перечисляет характеристики своего
любимого языка.

24

Глава 1

Введение в функциональное программирование

Чтобы не оттолкнуть читателя, уже проникшегося симпатией к тому
или иному языку, начнем с чисто математического определения, взятого из группы Usenet, посвященной функциональномупрограммированию:
Функциональное программирование – это стиль программирования, в котором основную роль играет вычисление выражений,
а не выполнение команд. Выражения в таких языках образованы
из функций, применяемых к исходным значениям. Функциональный язык – это язык, который поддерживает функциональный
стиль и способствует программированию в этом стиле.
– FAQ из группы comp.lang.functional
В последующих главах этой книги будет разобран ряд понятий, относящихся к ФП. Оставим на усмотрение читателя выбор тех из них, которые захочется считать существенными признаками, за которые язык
можно назвать функциональным.
Говоря шире, ФП – это стиль программирования, в котором основными блоками для построения программы являются функции в противоположность объектам или процедурам. Программа, написанная в функцио­
нальном стиле, не задает команды, которые должны быть выполнены
для получения результата, а определяет, что есть этот результат.
Рассмотрим небольшой пример: вычисление суммы списка чисел.
В императивном мире реализация состоит в том, чтобы перебрать
один за другим все элементы списка, прибавляя значение каждого из
них к переменной-накопителю. Программный текст представляет собой пошаговое описание процесса суммирования элементов списка.
В функциональном же стиле, напротив, нужно лишь определить, что
есть сумма чисел, и тогда компьютер сам будет знать, какие операции
выполнить, когда ему понадобится вычислить сумму. Один из способов
добиться этого состоит в том, что сумма списка чисел есть результат
сложения первого элемента списка с суммой оставшейся части спис­
ка; кроме того, сумма равна нулю, если список пуст. Тем самым дано
определение, что есть сумма, без подробного описания того, как ее вы­
числить.
Это различие и лежит в основе терминов «императивное программирование» и «декларативное программирование». Императивное
программирование означает, что программист указывает компьютеру
выполнить нечто, в явном виде описав каждый шаг, необходимый для
вычисления результата. Декларативное же означает, что программист
описывает требования к ожидаемому результату, а на язык программирования ложится ответственность за отыскание конкретного способа
его получения. Программист определяет, что собой представляет сумма
списка чисел, а язык использует это определение, чтобы вычислить сумму конкретного списка.

Что такое функциональное программирование

25

1.1.1 Соотношение функционального программирования
с объектно-ориентированным
Невозможно однозначно сказать, какая из двух парадигм лучше: наиболее популярная из императивных – объектно-ориентированная (ООП) –
или самая популярная из декларативных, т. е. парадигма ФП. У обеих
есть свои сильные и слабые стороны.
Основная идея объектно-ориентированной парадигмы – это создание абстракций над данными. Этот механизм позволяет программисту
скрывать внутреннее представление данных внутри объекта, предоставляя остальному миру лишь видимую его сторону, доступную через интерфейс.
В центре внимания ФП лежит создание абстракций над функциями.
Это позволяет создавать структуры управления, более сложные, чем те,
что непосредственно поддерживаются языком программирования. Когда в стандарт C++11 был добавлен цикл for по диапазону (часто называемый также циклом foreach), его поддержку нужно было реализовать во
всех компиляторах, которых в мире имеется довольно много. С по­мощью
методов ФП часто удается сделать нечто подобное без модификации
компилятора. За прошедшие годы во многих сторонних библиотеках
были реализованы собственные версии цикла по диапазону. Используя
идиомы ФП, можно создавать новые языковые конструкции – например,
цикл for по диапазону или иные, более сложные. Эти конструкции могут пригодиться, даже если разработка в целом ведется в императивном
стиле.
В некоторых случаях удобнее оказывается одна парадигма программирования, в иных – другая. Часто самым верным решением оказывается комбинация обеих парадигм. Это видно уже из того факта, что многие
старые и новые языки программирования стали поддерживать несколько парадигм, вместо того чтобы хранить верность своей первоначальной
парадигме.

1.1.2 Сравнение императивной и декларативной парадигм
на конкретном примере
Чтобы продемонстрировать различие между этими двумя стилями программирования, начнем с простой программы, написанной в императивном стиле, и преобразуем ее в эквивалентную функциональную
программу. Одна из часто применяемых мер сложности программного
обеспечения – это число строк кода (англ. lines of code, LOC). Хотя в общем случае адекватность этого показателя остается под вопросом, он
превосходно подходит в качестве примера для демонстрации различий
между императивным и функциональным стилями.
Предположим, нужно написать функцию, которая принимает на вход
список файлов и подсчитывает число строк в каждом из них (рис. 1.1).

Глава 1

26

Введение в функциональное программирование

Чтобы сделать пример как можно проще, будем подсчитывать в каждом
файле лишь число символов перевода на новую строку в предположении,
что последняя строка файла непременно заканчивается этим символом.
Список имен файлов
поступает на вход

Рис. 1.1

На выходе должно получиться
число строк в каждом файле

Программа для подсчета числа строк в файлах

Рассуждая по-императивному, можно представить алгоритм решения
этой задачи в виде такого списка шагов:
1 Открыть каждый файл.
2 Проинициализировать нулем счетчик строк.
3 Читать из файла символ за символом и наращивать счетчик всякий
раз, когда попадается символ новой строки (\n).
4 Дойдя до конца файла, запомнить полученное значение счетчика
строк.
Следующий листинг содержит реализацию описанной выше логики.
Листинг 1.1

Подсчет числа строк, императивное решение

std::vector
count_lines_in_files(const std::vector& files)
{
std::vector results;
char c = 0;
for (const auto& file : files) {
int line_count = 0;
std::ifstream in(file);
while (in.get(c)) {
if (c == '\n') {
line_count++;
}
}
results.push_back(line_count);
}
return results;
}

Что такое функциональное программирование

27

Получилось два вложенных цикла и несколько переменных, в которых
хранится текущее состояние процесса. Несмотря на всю простоту этого
примера, в нем есть несколько мест, где нетрудно ошибиться: например,
можно оставить переменную непроинициализированной (или проинициализировать ее неправильно), неправильно изменить значение счетчика или неправильно указать условие цикла. Компилятор может выдать
предупреждения о некоторых из них, но те, что пройдут компиляцию незамеченными, обычно с трудом обнаруживаются человеком, поскольку
наш мозг устроен так, чтобы не замечать их, как мы не замечаем опечатки. Поэтому код лучше всего писать таким образом, чтобы свести к минимуму саму возможность подобных ошибок.
Читатели, более искушенные в языке C++, наверняка заметили, что
в этом примере можно было воспользоваться стандартным алгоритмом
std::count, вместо того чтобы подсчитывать переводы строки вручную.
Стандартная библиотека языка C++ предоставляет ряд удобных абстракций, например итераторы по потокам, которые позволяют обращаться
с потоками ввода-вывода таким же образом, как с обычными коллекция­
ми: векторами и списками. Покажем пример их использования.
Листинг 1.2 Использование алгоритма std::count для подсчета
символов перевода строки
int count_lines(const std::string& filename)
{
std::ifstream in(filename);
return std::count(
std::istreambuf_iterator(in),
std::istreambuf_iterator(),
'\n');
}

Подсчитывает символы перевода
строки от текущей позиции
в файловом потоке до его конца

std::vector
count_lines_in_files(const std::vector& files)
{
std::vector results;
for (const auto& file : files) {
results.push_back(count_lines(file));
}

Сохраняет результаты

return results;
}

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

28

Глава 1

Введение в функциональное программирование

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

Можно ли назвать язык C++ объектно-ориентированным?
Меня всегда удивляло, что большинство разработчиков называют C++ объектно-ориентированным языком. Это удивительно потому, что в стандартной
библиотеке С++ (которую часто называют стандартной библиотекой шаблонов – англ. Standard Template Library, STL) почти нигде не используется полиморфизм, основанный на наследовании, – ключевой элемент парадигмы
ООП.
Библиотеку STL создал Александр Степанов, известный критик ООП. Он захотел создать библиотеку для обобщенного программирования и сделал это,
воспользовавшись системой шаблонов языка C++ в сочетании с методами
функционального программирования.
В этом состоит одна из причин столь широкого использования библиотеки
STL в данной книге: хотя она и не является библиотекой для функционального программирования в чистом виде, в ней хорошо смоделированы многие
понятия ФП, что делает библиотеку STL превосходной отправной точкой для
вхождения в функциональный мир.

Преимущество этого подхода в том, что программисту нужно держать
в голове меньше переменных состояния и становится возможным заняться тем, чтобы на высоком уровне абстракции формулировать предназначение программы – вместо подробного описания мелких шагов,
которые необходимо сделать для получения нужного результата. Не
нужно больше задумываться о том, как реализован подсчет. Единственная забота функции count_lines состоит в том, чтобы взять поступивший
на вход аргумент (имя файла) и превратить его в нечто, понятное для
функции std::count, т. е. в пару итераторов по потоку.
Теперь продвинемся еще на шаг в том же направлении и определим
весь алгоритм в функциональном стиле, описав, что должно быть сделано, вместо описания того, как это сделать. В предыдущей реализации
остался цикл for по диапазону, который применяет функцию ко всем
элементам коллекции и собирает результаты в контейнер. Это широко
распространенный шаблон, и было бы естественно ожидать его поддержки стандартной библиотекой языка программирования. В языке
C++ именно для этого предназначен алгоритм std::transform (в других
языках похожая функция обычно называется map или fmap). Реализация
разобранной выше логики на основе алгоритма std::transform показана в следующем листинге. Функция std::transform перебирает элементы
коллекции files один за другим, преобразовывает каждый из них по-

Что такое функциональное программирование

29

средством функции count_lines, а полученные результаты складывает
в вектор results.
Листинг 1.3 Отображение имен файлов в счетчики строк функцией
std::transform
std::vector
count_lines_in_files(const std::vector& files)
{
std::vector results(files.size());
std::transform(files.cbegin(), files.cend(),
results.begin(),
count_lines);

Откуда брать исходные данные
Куда сохранять результаты
Функция-преобразователь

return results;
}

В этом коде описан уже не пошаговый алгоритм, а, скорее, преобразование, которому нужно подвергнуть входные данные, чтобы получить
желаемый результат. Можно утверждать, что, избавив программу от переменных состояния и взяв за основу стандартную реализацию алгоритма подсчета вместо изобретения собственной, мы получим код, более
устойчивый к потенциальным ошибкам.
Получившийся листинг все еще имеет недостаток: в нем слишком
много клише, чтобы его можно было считать более удобочитаемым, чем
первоначальный вариант. На самом деле в этом коде лишь три важных
слова:
1
„„ transform – что код делает ;
„„ files – входные данные;
„„ count_lines – функция-преобразователь.
Все прочее – шелуха.
Эта функция могла бы стать гораздо более удобочитаемой, если бы
можно было оставить только важные фрагменты и опустить все остальное. Как читатель увидит в главе 7, этого можно добиться с помощью биб­
лиотеки ranges. Покажем здесь, как будет выглядеть эта функция, если
реализовать ее на основе библиотеки ranges, через диапазоны и их преобразования. Операция конвейера, обозначаемая вертикальной чертой
(|), используется в библиотеке ranges, для того чтобы подать коллекцию
на вход преобразователя.
Листинг 1.4 Преобразование коллекции средствами библиотеки ranges
std::vector
count_lines_in_files(const std::vector& files)
{
return files | transform(count_lines);
}
1

То есть поэлементное преобразование контейнера исходных данных в контейнер результатов. – Прим. перев.

30

Глава 1

Введение в функциональное программирование

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

Соглашения о способе записи типов функций
В языке C++ нет единого типа, представляющего понятие функции (в главе 3
речь пойдет обо всем разнообразии сущностей, которые в языке C++ могут
рассматриваться как функции). Чтобы иметь возможность зафиксировать исключительно типы аргументов и возвращаемого значения функции, не задавая при этом точный тип, который она получит в языке C++, нам понадобится
новая, отвлеченная от языка система обозначений.
Когда впредь мы будем писать f: (arg1_t, arg2_t, ..., argn_t) → result_t,
это будет означать, что f есть функция, принимающая n аргументов, первый
из которых имеет тип arg1_t, второй – тип arg2_t и т. д., причем возвращает
эта функция значение типа result_t. Если функция принимает лишь один
аргумент, скобки вокруг его типа будем опускать. Кроме того, не будем пользоваться в этих обозначениях константными ссылками.
Например, если написано, что функция repeat имеет тип (char, int) →
std::string, это означает, что она принимает два аргумента: один символьного типа и один целочисленного – и возвращает строку. В языке C++ это
можно было бы записать, например, так (второй вариант допустим начиная
со стандарта C++11):
std::string repeat(char c, int count);
auto repeat(char c, int count) -> std::string;

Реализация на основе диапазонов и их преобразований также упрощает поддержку кода. Читатель мог заметить, что функция count_lines
страдает проектным недостатком. Глядя лишь на ее имя и тип count_
lines: std::string → int, легко понять, что она принимает один аргумент
текстового типа, но совершенно не очевидно, что этот текст должен
представлять собой имя файла. Естественно было бы предположить,
что функция подсчитывает число строк в поступившем на вход тексте.
Чтобы избавиться от этого недочета, можно функцию разбить на две:
функцию open_file: std::string → std::ifstream, которая принимает имя
файла и возвращает открытый файловый поток, и функцию count_lines:
std::ifstream → int, которая подсчитывает строки в заданном потоке
символов. После такого разбиения предназначение функций становится совершенно очевидно из их имен и типов аргументов и возвращаемых значений. При этом построенная на диапазонах реализация
функции count_lines_in_files потребует вставки лишь еще одного преобразования.

Чистые функции

31

Листинг 1.5 Преобразование коллекции средствами библиотеки ranges,
модифицированный вариант
std::vector
count_lines_in_files(const std::vector& files)
{
return files | transform(open_file)
| transform(count_lines);
}

В итоге решение получилось гораздо менее многословным, чем императивное решение из листинга 1.1, и гораздо более очевидным. На вход
поступает коллекция имен файлов – не имеет значения даже, какой тип
коллекции используется, для каждого ее элемента выполняются подряд
два преобразования. А именно сначала из имени файла создается файловый поток, затем в потоке подсчитываются символы перевода строки.
Именно это в точности выражает приведенный здесь код, без обременительных подробностей и дублирующегося кода.

1.2

Чистые функции
Один из главных источников ошибок при программировании – это наличие у программы изменяемого состояния. Очень сложно проследить
все возможные состояния, в которых программа может находиться. Парадигма ООП дает возможность сгруппировать отдельные части состояния в объекты, тем самым помогая человеку понять состояния и управлять ими. Однако этот подход не в силах существенно уменьшить число
возможных состояний.
Представим себе разработку текстового редактора. Набранный пользователем текст нужно сохранить в переменную. Предположим, что
пользователь нажимает кнопку Сохранить и продолжает набор текста.
Программа тем временем сохраняет текст, отправляя символы в файл по
одному (эта картина, конечно, сильно упрощена, но автор просит читателя запастись терпением). Что произойдет, если пользователь изменит
часть текста, пока программа занимается его сохранением в файл? Сохранит ли программа текст в том виде, в котором он пребывал на момент
нажатия кнопки Сохранить, или в его нынешнем виде, или сделает чтото иное?
Проблема состоит в том, что все три случая могут произойти – это
зависит от того, насколько далеко продвинулась запись текста в файл
и в какую часть текста пользователь внес изменение. Так, в случае, изображенном на рис. 1.2, программа запишет в файл текст, которого никогда не было в редакторе.
В файл будут сохранены участки, взятые из текста, до того, как пользователь внесет свои изменения, другие участки попадут в файл из уже
измененного текста. Таким образом, в файл вместе попадут куски двух
различных состояний.

Глава 1

32

Введение в функциональное программирование

Этот блок текста сохранен до того,
как пользователь начал менять текст

Затем пользователь начинает
менять выделенный фрагмент

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

Рис. 1.2

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

Описанная ситуация просто не могла бы возникнуть, если бы функция сохранения текста в файл обладала собственной неизменяемой копией данных, которые ей необходимо записать (рис. 1.3). В этом состоит
наиболее серьезная проблема изменяемых состояний: они создают зависимости между частями программы, которые никак не должны быть
связаны между собой. Данный пример включает в себя два очевидно
различных пользовательских действия: набор текста и сохранение набранного текста. Эти действия должны выполняться независимо друг от
друга. Параллельное выполнение двух или более действий, относящихся
к одному и тому же общему состоянию, создает нежелательную зависимость между действиями и способно привести к проблемам, подобным
описанной выше.
Майкл Фезерс (Michael Feathers), автор книги «Эффективная работа с устаревшим кодом» (Working Effectively with Legacy Code – Prentice
Hall, 2004), писал: «ООП делает код более понятным за счет инкапсуляции движущихся частей. ФП делает код более понятным, сокращая число движущихся частей». Даже локальные изменяемые переменные стоит
считать нежелательными по той же причине. Они создают зависимости
между различными частями функции, затрудняя выделение тех или
иных ее участков в отдельные вспомогательные функции.
Одно из наиболее мощных понятий ФП – это понятие чистой функции, т. е. функции, которая использует лишь значения поступающих на
вход аргументов для вычисления результата, но не изменяет аргументы.
Если чистую функцию вызывают несколько раз с одними и теми же аргументами, она обязана возвращать одно и то же значение и не должна
оставлять никаких следов своего вызова (т. е. не должна производить побочные эффекты). Все это означает, что чистые функции не могут менять
состояние программы.

Чистые функции

33

Когда пользователь запускает сохранение файла,
сохраняющий поток создает неизменяемую копию
с текущего состояния текста

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

Рис. 1.3 Создание полной копии данных или использование структуры данных,
запоминающей историю своих версий, позволяет разорвать зависимость между
редактированием и сохранением текста

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

Глава 1

34

Введение в функциональное программирование

1.2.1 Устранение изменяемого состояния
Разговор об ФП как стиле программирования начинался с разбора императивной реализации алгоритма, подсчитывающего символы перевода строки в коллекции файлов. Функция подсчета строк должна всегда
возвращать один и тот же контейнер целых чисел, если ее многократно
вызывать для одного и того же списка файлов (при условии что никакая
внешняя функция не меняет сами файлы). Это означает, что нашу функцию можно реализовать чистым образом.
Глядя на первоначальную реализацию этой функции, показанную
в лис­тинге 1.1, можно увидеть лишь несколько операторов, нарушающих
требование чистоты:
for (const auto& file : files) {
int line_count = 0;
std::ifstream in(file);
while (in.get(c)) {
if (c == '\n') {
line_count++;
}
}
results.push_back(line_count);
}

Вызов метода .get для входного потока меняет как сам поток, так
и значение, хранящееся в переменной c. Далее этот код изменяет контейнер results, добавляя в конец новые значения, и модифицирует переменную line_count, наращивая ее на единицу. На рис. 1.4 показано, как
меняется состояние при обработке одного файла. Таким образом, данная
функция, очевидно, реализована отнюдь не чистым образом.
Переменная line_count меняет
свое значение всякий раз, когда
в переменной c оказывается символ
новой строки
Значение переменной
изменяется всякий раз,
когда из файла читается
очередной символ
Состояние файлового потока
меняется с каждым прочитанным
символом

Рис. 1.4 Модификация нескольких независимых переменных при подсчете числа
строк в файле

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

Чистые функции

35

характер функции. В данном случае все изменяющиеся переменные локальны, через них не могут взаимодействовать даже параллельные вызовы этой функции, тем более они невидимы для вызывающего кода
и каких бы то ни было внешних сущностей. Поэтому пользователи этой
функции могут считать ее чистой, несмотря на то что ее внутренняя реализация не такова. Выгода для вызывающего кода очевидна, так как они
могут быть уверены, что функция не изменит их состояния. С другой стороны, автор функции должен позаботиться о корректности ее внутреннего состояния. При этом нужно также удостовериться, что функция не
изменяет ничего, что ей не принадлежит. Конечно, лучше всего было бы
ограничить даже внутреннее состояние и сделать реализацию функции
как можно более чистой. Если при реализации программы удастся использовать исключительно чистые функции, то вообще не нужно беспокоиться о возможных паразитных влияниях между состояниями, поскольку никаких изменяемых состояний в программе нет.
Во втором решении (листинг 1.2) подсчет выделен в функцию с именем count_lines. Эта функция снаружи выглядит чистой, хотя ее внутренняя реализация создает и модифицирует поток ввода. К сожалению, это
лучшее, чего можно добиться с помощью класса std::ifstream:
int count_lines(const std::string& filename)
{
std::ifstream in(filename);
return std::count(
std::istreambuf_iterator(in),
std::istreambuf_iterator(),
'\n');
}

Этот шаг не приводит к сколько-нибудь существенному улучшению
функции count_lines_in_files. Некоторые элементы реализации, противоречащие чистоте функции, перемещаются из нее в другое место, однако в ней по-прежнему остается изменяемое состояние: переменная
results. Функция count_lines_in_files сама не осуществляет никакого ввода-вывода и реализована исключительно на основе функции count_lines,
которая с точки зрения вызывающего контекста выглядит чистой. Поэтому нет никаких причин, по которым функции count_lines_in_files следовало бы быть нечистой. Следующая версия кода, основанная на диа­
пазонах, представляет собой реализацию функции count_lines_in_files
без какого бы то ни было локального состояния (изменяемого или нет).
Эта реализация определяет функцию через вызов другой функции на поступившем на вход контейнере:
std::vector
count_lines_in_files(const std::vector& files)
{
return files | transform(count_lines);
}

Powered by TCPDF (www.tcpdf.org)

36

Глава 1

Введение в функциональное программирование

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

1.3

Функциональный стиль мышления
Писать код сначала в императивном стиле, а затем преобразовывать
его по кусочкам, пока он не превратится в функциональный, было бы
неэффективно и контрпродуктивно. Напротив, следует с самого начала
по-иному осмысливать задачу. Вместо того чтобы рассуждать о шагах,
которые должен выполнить алгоритм, нужно подумать, что собой представляют входные данные и искомый результат и какие преобразования
нужно выполнить, чтобы отобразить одно в другое.
В примере, показанном на рис. 1.5, даны имена файлов и нужно подсчитать число строк в каждом из них. Первое, что бросается здесь в глаза: задачу можно упростить, обрабатывая каждый раз по одному файлу.
Хотя на вход поступил целый список имен файлов, каждое из них можно
рассматривать независимо от остальных. Если изобрести решение задачи для единственного файла, можно легко решить также и исходную
задачу (рис. 1.6).
Как преобразовать входные данные,
чтобы получить желаемый результат?

Рис. 1.5 Рассуждая о задаче в функциональном стиле,
нужно думать о том, какое преобразование применить
к входным данным, чтобы получить желаемый результат
Упрощение задачи: найти нужное преобразование
для отдельного элемента входной коллекции

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

Функциональный стиль мышления

37

Теперь важнейшей задачей становится создание функции, которая
принимает на вход имя файла и подсчитывает число строк в файле с этим
именем. Из этого определения вполне ясно, что на вход функции поступает что-то одно (имя файла), но для работы нужно ей что-то другое
(а именно содержимое файла, чтобы было в чем подсчитывать символы
перевода строки). Следовательно, нужна вспомогательная функция, которая может, получив на вход имя файла, предоставить его содержимое.
Должно ли это содержимое предоставляться в виде строки, файлового
потока или чего-то иного, остается всецело на усмотрение программис­
та. Нужна всего лишь возможность получать из этого содержимого по
одному символу за раз, чтобы их можно было подать на вход функции,
подсчитывающей среди них символы перевода строки.
Имея в руках функцию, которая по заданному имени файла отдает его
содержимое (ее типом будет std::string → std::ifstream), к ее результату
можно применить другую функцию, которая в заданном содержимом
считает строки (т. е. функцию типа std::ifstream → int). Сочленение этих
двух функций путем подачи файлового потока, созданного первой, на
вход второй как раз и дает необходимую нам функцию, см. рис. 1.7.
Одна функция берет имя файла
и возвращает его содержимое

Другая функция подсчитывает
строки в заданном потоке

Рис. 1.7 Сложную задачу подсчета строк в файле с заданным именем
можно разбить на две простые: открытие файла по заданному имени
и подсчет строк в открытом файловом потоке

Тем самым задача подсчета строк в одном файле решена. Для решения же исходной задачи остается поднять (англ. lift) эти функции, чтобы
они могли работать не над отдельными значениями, а над коллекциями
значений. В сущности, это именно то, что делает функция std::transform
(пусть и с более сложным интерфейсом): она берет функцию, которую
можно применять к отдельно взятому значению, и создает на ее основе
преобразование, которое можно применять к целым коллекциям значений, – см. рис. 1.8. Пока что читателю лучше всего представить себе
подъем (англ. lifting) как обобщенный способ превратить функцию, оперирующую отдельными простыми значениями некоторого типа, в функцию, работающую с более сложными структурами данных, содержащими
значения этого типа. Более подробно речь о подъеме функций пойдет
в главе 4.

38

Глава 1

Введение в функциональное программирование

Ранее созданы функции, обрабатывающие одно значение за раз. Поднимая их с помощью
функции transform, получаем функции, обрабатывающие целые коллекции значений

Рис. 1.8 С помощью функции transform можно создавать функции обработки коллекций
на основе функций, обрабатывающих одно значение

Из этого простого примера хорошо виден функциональный подход
к разбиению больших задач программирования на меньшие независимые подзадачи, решения которых затем легко сочленяются. Одна из полезных аналогий, помогающих представить себе композицию функций
и их подъем, – это аналогия с движущейся лентой конвейера (рис. 1.9).
В начале ленты находится сырье, в конце должно быть получено готовое изделие. Лента продвигается от станка к станку, каждый из которых
совершает какое-то свое преобразование, пока не получится изделие
в своем окончательном виде. Глядя на конвейер как целое, естественно
рассуждать о цепочке преобразований, превращающей сырье в изделие,
а не об элементарных действиях, совершаемых каждой машиной.
В этой аналогии сырье соответствует входным данным, а станки –
функциям, применяемым последовательно к этим данным. Каждая
функция узко специализирована для выполнения одной простой задачи
и ничего не должна знать об остальной части конвейера. Каждой функции нужны только правильные данные на вход – но ей совершенно не
важно, откуда они получены. Входные значения помещаются на конвейер одно за другим (или, возможно, на несколько параллельно работающих конвейерных лент, что позволяет обрабатывать несколько значений одновременно). Каждое значение подвергается преобразованиям,
и с другого конца конвейера снимается коллекция результатов.

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

Преимущества функционального программирования

39

скольких важнейших преимуществ, которые обеспечиваются большинством механизмов ФП.
Самое очевидное обстоятельство, которое отмечает большинство программистов, едва начав создавать программы в функциональном стиле,
состоит в том, что код программ становится значительно короче. В некоторых проектах даже можно встретить разбросанные по коду комментарии наподобие «на языке Haskell это можно было бы реализовать
в одну строку». Это происходит потому, что средства, предоставляемые
функциональными языками, просты и в то же время очень выразительны, большую часть решения задачи они позволяют описать на высоком
уровне абстракции, не вдаваясь в мелкие детали.
Различные преобразования одно за другим применяются
к поступающему на вход объекту. Вместе получается
композиция всех этих преобразований

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

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

Именно это свойство, вместе со свойством чистоты, стало привлекать
к функциональному программированию в последние годы все больше
внимания. Чистота способствует корректности кода, а выразительность
позволяет писать меньше кода, то есть оставляет меньше места для
ошибок.

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

Глава 1

40

Введение в функциональное программирование

ный код, могут с ним не согласиться. Объективно же можно утверждать,
что программы, написанные в функциональном стиле, обычно оказываются короче и лаконичнее. Это с полной очевидностью проявилось
в разобранном примере: начав с двадцати строк императивного кода,
мы пришли к единственной строке кода для функции count_lines_in_files
и примерно пяти строчкам для функции count_lines, из которых большую
часть составляет клише, навязанное языком C++ и библиотекой STL. Достичь такого впечатляющего сжатия кода удалось благодаря использованию высокоуровневых абстракций, предоставляемых той частью биб­
лиотеки STL, что ориентирована на поддержку ФП.
Одна из печальных истин состоит в том, что многие программисты,
работающие на языке C++, сторонятся использования высокоуровневых
абстракций наподобие алгоритмов из библиотеки STL. У них могут быть
для этого различные причины, от стремления написать своими руками
более эффективный код до желания избежать кода, который коллегам
было бы тяжело понять. Иногда эти причины не лишены смысла, но отнюдь не в большинстве случаев. Отказ от пользования наиболее передовыми возможностями своего языка программирования снижает мощь
и выразительность языка, делает код более запутанным, а его поддержку – более трудоемкой.
В 1968 г. Эдсгер Дейкстра опубликовал знаменитую статью «О вреде
оператора goto»1. В ней он выступал за отказ от оператора перехода goto,
который в ту эпоху использовался чрезмерно, в пользу высокоуровневых
средств структурного программирования, включая процедуры, операторы ветвления и цикла.
Разнузданное применение оператора go to имеет прямым
следст­вием то, что становится ужасно трудно найти осмысленный набор координат, в которых описывается состояние
процесса… Оператор go to сам по себе просто слишком примитивен; он создает очень сильное побуждение внести путаницу
в программу2.
Однако во многих случаях операторы цикла и ветвления тоже оказываются слишком примитивными. Как и оператор goto, циклы и ветвления
могут сделать программу сложной для написания и понимания, и их час­
то удается заменить более высокоуровневыми конструкциями в функциональном стиле. Программисты, привычные к императивному стилю,
часто дублируют один и тот же, по сути, код в разных местах программы,
даже не замечая, что он одинаков, так как он работает с данными разных
типов или имеет мелкие различия в поведении, которые с точки зрения
функционального стиля легко было бы вынести в параметр.
1

2

Edsger Dijkstra. Go To Statement Considered Harmful // Communications of the
ACM: journal. 1968. March (vol. 11, no. 3). P. 147–148.
Цит. по русскому переводу: http://hosting.vspu.ac.ru/~chul/dijkstra/goto/goto.
htm. – Прим. перев.

Преимущества функционального программирования

41

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

1.4.2 Параллельная обработка и синхронизация
Главную трудность при разработке параллельных систем составляет
управление общим изменяемым состоянием. От программиста требуется особая внимательность и аккуратность, чтобы обеспечить согласованную работу разных частей системы и целостность состояния.
Распараллеливание программ, созданных на основе чистых функций,
напротив, тривиально, поскольку эти функции не изменяют никакого
состояния. Поэтому нет необходимости синхронизировать их своими
руками с помощью атомарных переменных или семафоров. Код, написанный для однопоточной системы, можно почти без изменений запус­
кать в несколько потоков. Более подробно речь об этом пойдет в главе 12.
Рассмотрим следующий фрагмент кода, который суммирует квадратные корни значений, хранящихся в векторе xs:
std::vector xs = {1.0, 2.0, ...};
auto result = sum(xs | transform(sqrt));

Если реализация функции sqrt чистая (а для иного причин нет), реализация функции sum может автоматически разбить вектор входных данных на сегменты и сумму каждого из них вычислить в отдельном потоке.
Когда все потоки завершатся, останется лишь собрать и просуммировать
их результаты.
К сожалению, в языке C++ (по крайней мере, пока) отсутствует понятие
чистой функции, поэтому распараллеливание не может выполняться автоматически. Вместо этого программисту следует в явном виде вызвать
параллельную версию функции sum. Параллельная функция sum может
даже сама на лету определить число процессорных ядер и, исходя из этого, решить, на сколько сегментов разбить вектор xs. Если бы суммирование корней было реализовано в императивном стиле, через цикл for,
его бы не удалось распараллелить столь просто. Тогда пришлось бы позаботиться о том, чтобы переменные не модифицировались одновременно
разными потоками, об определении оптимального числа потоков для той
системы, на которой система выполняется, – вместо того чтобы предоставить все это библиотеке, реализующей алгоритм суммирования.
ПРИМЕЧАНИЕ Компиляторы языка C++ иногда способны сами
выполнять векторизацию и ряд других оптимизаций, если обнаруживают, что тело цикла чистое. Эти оптимизации часто затрагивают код, использующий стандартные алгоритмы, поскольку они
обычно бывают реализованы на основе циклов.

42

Глава 1

Введение в функциональное программирование

1.4.3 Непрерывная оптимизация
Использование высокоуровневых программных абстракций из библиотеки STL или других заслуживающих доверия библиотек приносит еще
одну ощутимую выгоду: программа может со временем совершенствоваться, даже если автор не меняет в ее коде ни строчки. Каждое усовершенствование в языке программирования, реализации компилятора
или в реализации используемой программой библиотеки будет автоматически приводить к совершенствованию программы. Хотя это равно
справедливо как для функциональных, так и для нефункциональных
абстракций высокого уровня, само использование понятий ФП в программе существенно увеличивает долю кода, основанного на этих абстракциях.
Это преимущество может показаться самоочевидным, но многие программисты до сих пор предпочитают вручную писать критичные по производительности участки низкоуровневого кода, иногда даже на языке
ассемблера. Этот подход может быть оправдан, но в большинстве случаев
он позволяет оптимизировать код лишь для конкретной вычислительной платформы и практически лишает компилятор возможности самому оптимизировать код для всех остальных платформ.
Рассмотрим для примера функцию sum. Ее можно оптимизировать для
системы с упреждающей выборкой машинных команд, если в теле цикла
обрабатывать сразу по два (или более) элемента на каждой итерации, –
вместо того чтобы прибавлять числа по одному. Это уменьшит общее
количество команд перехода в машинном коде, поэтому упреждающая
выборка будет срабатывать чаще. Производительность программы на
данной целевой платформе, очевидно, возрастет. Но что будет, если эту
же программу скомпилировать и запустить на другой платформе? На
некоторых платформах оптимальным может оказаться цикл в первоначальном виде, обрабатывающий по одному элементу за итерацию, на
иных же может оказаться лучше выбирать за итерацию другое количест­
во элементов. Некоторые системы могут даже поддерживать машинную
команду, которая делает все, что нужно данной функции.
Пытаясь оптимизировать код вручную, легко потерять оптимальность
на всех платформах, кроме одной. Напротив, пользуясь в программевысокоуровневыми абстракциями, программист полагается на труд множества других людей по оптимизации кода для разных частных случаев.
Большинство реализаций библиотеки STL содержат оптимизации, спе­
ци­фичные для тех или иных платформ и компиляторов.

1.5 Эволюция C++ как языка функционального
программирования
Язык C++ возник как расширение языка C, позволяющее писать объектно-ориентированный код, и поначалу вообще назывался «C с классами». Однако даже после выхода первого стандарта языка (C++98) его

Эволюция C++ как языка функционального программирования

43

сложно было бы назвать объектно-ориентированным. С введением
в язык шаблонов и с появлением библиотеки STL, в которой наследование и виртуальные методы используются лишь эпизодически, язык C++
стал в полном смысле мультипарадигмальным.
Если внимательно рассмотреть принципы библиотеки STL и ее реализацию, можно даже прийти к убеждению, что C++ – язык вовсе не объект­
но-ориентированного, а в первую очередь обобщенного программирования. В основе обобщенного программирования лежит идея о том, что код
можно написать один раз, используя в нем те или иные общие понятия,
а затем применять его сколько угодно раз к различным сущностям, подпадающим под эти понятия. Так, например, библиотека STL предоставляет шаблон класса vector, который можно использовать с разными типами данных, включая целые числа, строки или пользовательские типы,
отвечающие определенным требованиям. Для каждого из этих типов
компилятор генерирует хорошо оптимизированный код. Этот механизм
часто называют статическим полиморфизмом, или полиморфизмом времени компиляции, – в противоположность динамическому полиморфизму,
или полиморфизму времени выполнения, который поддерживается наследованием и виртуальными методами.
Что касается поддержки функционального стиля языком C++, то решающая роль шаблонов обеспечивается не столько поддержкой контейнерных классов наподобие векторов, сколько тем, что они сделали
возможным появление в библиотеке STL набора универсальных общеупотребительных алгоритмов – таких как сортировка или подсчет. Большинство из них позволяет программисту передавать в качестве пара­
мет­ров собственные функции, тем самым подстраивая их поведение без
использования1 типа void*. Таким способом, например, можно изменить
порядок сортировки или определить, какие именно элементы следует
пересчитать, и т. д.
Возможность передавать функции в другие функции в качестве аргументов и возможность возвращать из функций в качестве значений
новые функции (точнее, некоторые сущности, ведущие себя подобно
функциям, о чем речь пойдет в главе 3) превратили даже первую стандартизированную версию языка C++ в язык функционального про1

Напомним, что в языке C, не обладающем средствами обобщенного программирования, единственный способ создать универсальную функцию, способную работать с данными произвольных типов, состоит в том, чтобы передать
в качестве аргумента указатель на функцию, принимающую аргументы через
универсальный указатель типа void*. Эта последняя функция отвечает за приведение указателей void* к фактическому типу данных и специфику работы
с этим типом. Например, универсальная функция сортировки из стандартной
библиотеки языка C имеет прототип void qsort(void* base, size_t num, size_t
size, int (*compar)(const void*, const void*)), и ее последний аргумент представляет собой указатель на пользовательскую функцию сравнения элементов.
Хотя использование указателей void* позволяет, в принципе, определять алгоритмы, работающие для произвольных типов данных, этот механизм прямо
противоречит идее строгой типизации и чреват причудливыми, трудно поддающимися обнаружению ошибками. – Прим. перев.

44

Глава 1

Введение в функциональное программирование

граммирования. Стандарты C++11, С++14 и C++17 принесли с собой еще
несколько нововведений, заметно упрощающих программирование
в функциональном стиле. Эти дополнительные возможности представляют собой главным образом синтаксический сахар, как, например,
ключевое слово auto и лямбда-выражения (рассматриваемые в главе 3).
Кроме того, существенным усовершенствованиям подверглись алгоритмы из стандартной библиотеки. Следующая версия стандарта должна
появиться в 2020 году, и в ней ожидается еще большее количество нововведений (ныне пребывающих в статусе технических спецификаций),
ориентированных на поддержку функционального стиля: например,
диапазонов (range), концептов (concept) и сопрограмм (coroutine).

Эволюция международных стандартов языка С++
Для языка C++ существует стандарт, утвержденный международной организацией по стандартизации ISO. Каждая новая версия стандарта проходит
через строго регламентированный процесс рассмотрения, прежде чем быть
опубликованной. Сам по себе язык и его стандартная библиотека разрабатываются комитетом, каждое нововведение всесторонне обсуждается, ставится
на голосование и лишь затем становится частью окончательного проекта изменений к новой версии стандарта. В конце, когда все изменения внесены
в тело стандарта, он должен пройти через еще одно голосование – итоговое,
которое проводится для каждого нового стандарта в организации ISO.
Начиная с 2012 года работа комитета разделена между рабочими группами.
Каждая группа работает над отдельными элементами языка и, когда считает
этот элемент вполне законченным, выпускает так называемую техническую
спецификацию (ТС). ТС существуют отдельно от стандарта, в стандарт они
могут войти позднее.
Цель ТС состоит в том, чтобы разработчики могли опробовать новые языковые средства и обнаружить в них скрытые недоработки и огрехи до того,
как эти средства войдут в новый стандарт. От производителей компиляторов
не требуется воплощать ТС, но обычно они это делают. Более подробную
информацию можно найти на сайте комитета https://isocpp.org/std/status.

Хотя большую часть средств, о которых говорится в этой книге, можно
использовать и с более ранними версиями языка C++, мы будем ориентироваться преимущественно на стандарты C++14 и C++17.

1.6

Что узнает читатель из этой книги
Эта книга предназначена в первую очередь для опытных разработчиков,
которые используют язык C++ в своей повседневной работе и желают пополнить свой арсенал более мощными инструментами. Чтобы извлечь
максимум пользы из изучения этой книги, нужно хорошее знакомство
с такими основополагающими элементами языка C++, как система типов, ссылки, спецификатор const, шаблоны, перегрузка операций, и др.

Что узнает читатель из этой книги

45

Нет необходимости знать нововведения, появившиеся в стандартах
C++14/17, поскольку они подробно разобраны в книге; эти новые элементы еще не завоевали популярность, и многие читатели о них, скорее
всего, еще не осведомлены.
Для начала будут разобраны такие важнейшие понятия, как функции
высших порядков, что позволит повысить выразительность языка и сделать программы заметно короче. Также будет рассказано, как писать код,
не имеющий изменяемого состояния, чтобы устранить необходимость
в явной синхронизации при параллельном выполнении. Затем переключимся на вторую передачу и рассмотрим более сложные темы, такие как
диапазоны (альтернатива алгоритмам обработки коллекций из стандартной библиотеки, хорошо поддерживающая композицию операций) и алгебраические типы данных (с помощью которых можно уменьшить число
состояний, в которых может пребывать программа). Под конец поговорим
об идиоме функционального программирования, вызывающей больше
всего споров, – о пресловутых монадах и о том, как использовать монады
для создания сложных и хорошо стыкующихся между собой систем.
К концу книги читатель будет в состоянии проектировать и реализовывать надежные параллельные системы, способные масштабироваться
по горизонтали с минимальными усилиями; проектировать программу
таким образом, чтобы свести к минимуму или вообще устранить возможность попадания в невалидное состояние вследствие сбоя или ошибки; представлять себе программу как поток данных сквозь череду преобразователей и использовать новое замечательное средство, диапазоны,
для создания таких потоков, а также многое другое. Эти умения помогут создавать более компактный и менее подверженный ошибкам код,
даже продолжая работать над объектно-ориентированными системами.
Те, кто решит полностью погрузиться в функциональный стиль, получат возможность разрабатывать более стройные программные системы
с удобными программными интерфейсами для взаимодействия с другими системами, в чем читатель убедится в главе 13, реализовав простой
веб-сервис.
СОВЕТ Более подробную информацию и дополнительные ресурсы по темам, затронутым в этой главе, можно найти на странице
https://forums.manning.com/posts/list/41680.page.

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

Глава 1

46

Введение в функциональное программирование

C++ представляет собой мультипарадигмальный язык программирования, с его помощью можно создавать программы в различных
стилях: процедурном, объектно-ориентированном, функциональном, – а также комбинировать эти стили с использованием методов
обобщенного программирования.
„„ Функциональное программирование идет рука об руку с обобщенным, особенно в языке C++. Оба подхода побуждают программиста не
фиксировать внимание на аппаратном уровне, а поднимать уровень
абстракции.
„„ Подъем функций позволяет создавать функции, работающие с коллекциями значений, на основе функций, обрабатывающих отдельные
значения. С помощью композиции функций можно подать значение
на цепочку преобразователей, в которой каждая функция передает
свой результат на вход следующей функции.
„„ Избегание изменяемого состояния способствует корректности кода
и устраняет необходимость в синхронизации параллельных потоков.
„„ Мыслить по-функциональному означает размышлять о входных данных и преобразованиях, которые нужно выполнить, чтобы получить
желаемый результат.
„„

2

Первые шаги
в функциональном
программировании

О чем говорится в этой главе:

понятие о функциях высшего порядка;
„„ использование функций высшего порядка из библиотеки STL;
„„ трудности с композицией алгоритмов из библиотеки STL;
„„ рекурсия и оптимизация хвостовой рекурсии;
„„ мощь алгоритма свертки.
„„

В предыдущей главе было показано несколько изящных примеров того,
как можно улучшить качество кода за счет использования простых конструкций функционального программирования. Там же были показаны
выгоды от применения ФП, такие как лаконичность, корректность и эффективность кода. Однако те волшебные средства функциональных языков, которые позволяют писать код таким образом, рассмотрены пока
не были.
Истина состоит в том, что если заглянуть за кулисы функциональных языков, то никакого волшебства там не окажется – лишь несколько простых понятий, на основе которых строится все остальное. Первое
довольно простое, но богатое далеко идущими вариациями понятие из
использованных в предыдущей главе – это передача функции в качестве
аргумента в другую функцию, в частности в алгоритм из стандартной
библиотеки шаблонов STL. Алгоритмы в библиотеке STL потому и применимы к столь широкому кругу задач, что их поведение можно настраивать с помощью аргументов-функций.

Глава 2

48

2.1

Первые шаги в функциональном программировании

Функции с аргументами-функциями
Главная особенность всех языков функционального программирования
(ФП) состоит в том, что с функциями можно обращаться, как с обыкновенными значениями. Их можно хранить в переменных, помещать в коллекции или структуры данных, передавать в другие функции в качестве
аргументов или получать из функций в качестве возвращаемых значений.
Функции, которые принимают другие функции в качестве аргументов
или возвращают функции в качестве значений, называются функциями высшего порядка. В предыдущей главе читатель видел, как сделать
программу более лаконичной и эффективной, если на высоком уровне
абст­ракции описать, что программа должна сделать, – вместо того чтобы
описывать все подробности своими руками. Функции высшего порядка
оказываются незаменимыми именно для этого. Они позволяют абст­
рактно описывать поведение и определять структуры управления, более
сложные, чем те, что предоставляет сам по себе язык C++.
Проиллюстрируем сказанное примером. Предположим, дана группа
людей, и нужно получить имена всех женщин из этой группы (рис. 2.1).

Джейн

Том
filter(people, is_female)

Питер

Джейн
Дэвид

Роза

Роза

Марта

Марта

Рис. 2.1 Фильтрация коллекции людей по предикату is_female.
Должна получиться коллекция людей, содержащая только женщин
из исходной коллекции

Первая высокоуровневая конструкция, которой можно было бы воспользоваться для этой задачи, – это фильтрация коллекции. Фильтрация в общем случае – это простой алгоритм, который перебирает один
за другим элементы и для каждого проверяет, удовлетворяет ли он определенному условию. Если условие истинно, элемент помещается в коллекцию-результат. Алгоритм фильтрации не может знать заранее, какие
предикаты понадобятся пользователям для фильтрации их коллекций.
Фильтрация может выполняться по какому-то одному признаку объекта
(в данном примере – по определенному значению параметра «пол» объекта «человек»), или по комбинации признаков (скажем, если из коллекции людей нужно выбрать всех женщин с черными волосами), или по
еще более сложно устроенному условию (например, выбрать всех женщин, которые недавно купили новый автомобиль). Поэтому алгоритм
фильтрации должен предоставлять пользователю возможность задавать

49

Функции с аргументами-функциями

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

Дополнение к способу записи типов функций
Чтобы обозначить произвольную коллекцию, содержащую элементы некоторого типа T, будем писать collection или, для краткости, просто C. Чтобы обозначить, что аргумент функции представляет собой функцию, будем
писать тип функции-аргумента там, где ожидается тип аргумента.
Например, конструкция filter принимает в качестве аргументов коллекцию
значений произвольного типа T и функцию-предикат (т. е. значение типа T →
bool), а возвращает коллекцию значений, удовлетворяющих предикату, поэтому тип ее может быть записан следующим образом:
filter: (collection, (T → bool)) → collection

После того как фильтрация произведена, остается вторая задача: получить имена людей. Для этого нужна конструкция, которая получает
совокупность людей и возвращает совокупность их имен. Как и в случае
фильтрации, в общем случае эта конструкция не может знать заранее,
какую информацию нужно извлекать из поступивших на вход значений.
Пользователь может захотеть значение определенного атрибута (в этом
примере – атрибута «имя»), комбинацию нескольких атрибутов (возможно, конкатенацию имени и фамилии) или сделать что-то более сложное
(скажем, для каждого человека из исходной коллекции получить список
детей). Как и предыдущая, эта конструкция должна позволять пользователю задавать свою функцию, которая принимает на вход один элемент
коллекции, что-то с ним делает и возвращает значение, которое должно
быть помещено в коллекцию-результат (рис. 2.2).

Джейн
Джейн

Том

transform(people, name)

Питер

Том
Дэвид

Дэвид
Марта

Питер

Марта

Роза

Роза

Рис. 2.2 Дана коллекция людей. Алгоритм transform должен применить
функцию-преобразователь к каждому элементу и собрать результаты в новую
коллекцию. В данном примере передается функция, которая возвращает имя
человека. В итоге алгоритм transform строит коллекцию имен

Глава 2

50

Первые шаги в функциональном программировании

Следует заметить, что коллекция-результат в этом случае не обязана
состоять из значений того же типа, что и коллекция, поступившая на
вход (в отличие от фильтрации). Данную конструкцию называют обычно
map или transform, и ее тип таков:
transform: (collection, (In → Out)) → collection

Если теперь построить композицию этих двух конструкций (см.
рис. 2.3), подав результат первой на вход второй, получится решение исходной задачи: найти имена всех женщин из заданной группы людей.

Джейн

Том

Питер

filter
Джейн
Дэвид

Марта

Роза

Джейн

transform
Марта

Роза

Марта

Роза

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

Оба этих средства, filter и transform, представляют собой широко распространенные идиомы, которые многие программисты раз за разом
реализуют заново в каждом из своих проектов. Небольшие вариации
в условии задачи – скажем, различные предикаты, используемые для
фильтрации (по признакам пола, возраста и т. д.) – вынуждают программистов снова и снова писать один и тот же код. Функции высшего порядка позволяют вынести эти различия в параметр-функцию и оставить
лишь предельно обобщенное абстрактное понятие, охватывающее все
частные случаи. Помимо прочих выгод, это существенно повышает степень повторного использования кода и его покрытие тестами.

2.2

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

51

Примеры из библиотеки STL

2.2.1 Вычисление средних
Предположим, дан список оценок, которые посетители сайта поставили
некому фильму, и требуется вычислить среднюю оценку. Императивный
подход к решению этой задачи состоит в том, чтобы пройтись в цикле по
коллекции оценок, суммируя элементы, и разделить полученную сумму
на общее число оценок (рис. 2.4).
Листинг 2.1 Подсчет средней оценки в императивном стиле
double average_score(const std::vector& scores)
{
Начальное значение суммы
int sum = 0;
for (int score : scores) {
sum += score;
}

Поэлементное суммирование

return sum / (double)scores.size();

Вычисление среднего арифметического

}

Оценки отдельных
пользователей

Sintel (2010):
мультипликация,
короткометражный,
фэнтези

Средняя оценка

Рис. 2.4 Вычисление средней оценки фильма на основе списка оценок
отдельных пользователей. Нужно просуммировать оценки пользователей,
затем разделить сумму на число пользователей

Хотя этот подход и работает, он страдает излишней детализацией.
В коде есть несколько мест, в которых легко допустить ошибку: например,
можно указать не тот тип элемента в заголовке цикла, из-за чего код изменит свою семантику, но все еще будет компилироваться. Кроме того, этому коду внутренне присущ последовательный порядок выполнения, тогда
как суммирование коллекции можно легко распараллелить и выполнять
на нескольких ядрах или даже на специализированном процессоре.
Библиотека STL содержит функцию высшего порядка, которая умеет
суммировать все элементы коллекции, – алгоритм std::accumulate. Она

52

Глава 2

Первые шаги в функциональном программировании

принимает коллекцию (в виде пары итераторов) и начальное значение
для суммирования, а возвращает сумму начального значения со всеми
элементами коллекции. Остается лишь разделить эту сумму на общее
число оценок, как в предыдущем примере. Следующий код ничего не
говорит о том, каким способом должно выполняться суммирование, –
в нем лишь задано, что должно быть сделано. Реализация получилась
столь же обобщенной, как и представленная на рис. 2.4 постановка задачи.
Листинг 2.2 Подсчет средней оценки в функциональном стиле
double average_score(const std::vector& scores)
{
return std::accumulate(
Суммировать все оценки в коллекции
scores.cbegin(), scores.cend(),
0
Начальное значение суммы
Вычислить среднее арифметическое
) / (double)scores.size();
}

Хотя алгоритм std::accumulate сам по себе реализован последовательно, подставить вместо него параллельную версию очень просто. Для
сравнения, сделать первую реализацию параллельной было бы нетривиальной задачей.

Параллельные версии стандартных алгоритмов
Начиная с версии C++17 многие алгоритмы из библиотеки STL позволяют
программисту указать, что их выполнение должно осуществляться параллельно. Алгоритмы, допускающие параллельное выполнение, принимают
политику выполнения через дополнительный аргумент. Если желательно,
чтобы алгоритм выполнялся параллельно, ему нужно передать политику
std::execution::par. За более подробной информацией о политиках выполнения можно обратиться к соответствующему разделу справочника по языку
C++: http://mng.bz/EBys.
Алгоритм std::accumulate стоит особняком. Он гарантирует, что элементы
коллекции обрабатываются последовательно, с первого по последний, что
делает распараллеливание невозможным без нарушения семантики. Если
нужно просуммировать все элементы, но сделать это параллельным образом,
следует воспользоваться алгоритмом std::reduce:
double average_score(const std::vector& scores)
{
return std::reduce(
std::execution::par,
scores.cbegin(), scores.cend(),
0
) / (double) scores.length();
}

Примеры из библиотеки STL

53

Если для работы используется старый компилятор и версия библиотеки STL,
не имеющая полной поддержки стандарта C++17, алгоритм reduce можно
найти в пространстве имен std::experimental::parallel, также можно воспользоваться сторонними библиотеками, такими как HPX или Parallel STL, см.
статью автора этой книги «C++17 and Parallel Algorithms in STL–Setting Up»
по адресу http://mng.bz/8435.

И все-таки в листинге 2.2 чего-то не хватает. Выше я написал, что алгоритм std::accumulate – это функция высшего порядка, но не передал
другую функцию в качестве аргумента (а алгоритм не возвращает значение типа функции).
По умолчанию функция std::accumulate применяет к элементам коллекции операцию сложения, но если программист желает изменить ее
поведение, он может передать собственную функцию. Так, например,
если для каких-то целей нужно вычислить произведение всех оценок,
достаточно передать в функцию std::accumulate дополнительным аргументом объект std::multiplies и число 1 в качестве начального значения,
как показано в следующем листинге. Функциональные объекты наподобие std::multiplies будут подробно рассмотрены в следующей главе.
Пока что довольно сказать, что этот объект ведет себя подобно функции,
принимающей два аргумента определенного типа и возвращающей их
произведение.
Листинг 2.3 Вычисление произведения всех оценок
double scores_product(const std::vector& scores)
{
return std::accumulate(
Все оценки в коллекции
scores.cbegin(), scores.cend(),
Начальное значение для произведения
1,
std::multiplies()
Перемножать, а не суммировать
);
}

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

2.2.2 Свертки
Нередко возникает необходимость обрабатывать коллекцию элементов
один за другим, вычисляя при этом некоторый результат. Этот результат
может быть простым, как сумма или произведение всех элементов коллекции, как в предыдущем примере, число элементов, имеющих определенное значение или удовлетворяющих заданному предикату. Результат

54

Глава 2

Первые шаги в функциональном программировании

может быть также чем-то более сложным: например, новой коллекцией,
которая содержит лишь часть элементов исходной коллекции (это имеет
место при фильтрации), или коллекцией, в которой исходные элементы
расположены в другом порядке (что характерно для сортировки и разделения).
Алгоритм std::accumulate представляет собой реализацию чрезвычайно общего понятия, известного под названием свертки, или редукции.
Это функция высшего порядка, которая абстрагирует от процесса поэлементного перебора рекурсивных структур данных (таких как векторы,
списки, деревья) и позволяет постепенно накапливать требуемый результат. В разобранном выше примере свертка использовалась для суммирования рейтинга фильмов. Алгоритм std::accumulate сначала берет
начальное значение, переданное ему в качестве аргумента, и складывает
его с первым элементом коллекции. Полученный результат он складывает со вторым элементом коллекции и т. д. Этот процесс повторяется до
тех пор, пока не будет достигнут конец коллекции (рис. 2.5).
Начальное значение суммы – число 0

Оценки фильма

Сумма начального значения
и первой оценки

Сумма предыдущего результата с оценкой
следующего фильма

Сумма всех оценок

Результат

Рис. 2.5 Свертка вычисляет сумму всех оценок фильма, прибавляя первый элемент
коллекции к начальному значению (нулевому), затем прибавляя второй элемент
и т. д.

В общем случае не требуется, чтобы аргументы и результат бинарной операции, по которой проводится свертка, имели один и тот же тип.
Свертка принимает коллекцию, состоящую из элементов типа T, начальное значение типа R, который отнюдь не обязан совпадать с типом T,
и функцию f: (R, T) → R. Свертка вызывает эту функцию, передав ей
в качестве аргументов начальное значение и первый элемент коллекции. Результат этого применения передается, в свою очередь, в функцию f вместе со следующим элементом коллекции. Этот процесс повто-

55

Примеры из библиотеки STL

ряется, пока не будут обработаны все элементы. Алгоритм возвращает
значение типа R – значение, которое вернул последний вызов функции f
(рис. 2.6). В предыдущих примерах начальным значением было число 0
для суммирования и 1 для перемножения, а в роли бинарной функции f
выступала операция сложения или, соответственно, умножения.
Начальное значение

Коллекция

Результат применения
функции f к начальному
значению и первому
элементу коллекции

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

Результат

Рис. 2.6 В общем случае свертка берет начальное значение r0
и применяет заданную функцию f к нему и первому элементу коллекции,
получая промежуточный результат r1. Затем свертка применяет функцию f
к значению r1 и второму элементу коллекции. Процесс продолжается
до достижения последнего элемента коллекции

В качестве первого примера свертки по функции, у которой тип возвращаемого значения отличен от типа элементов коллекции, реализуем
на основе свертки функцию, которая определяет количество строк в тексте, подсчитывая вхождения символа перевода строки. Напомним, что
в главе 1 для этой цели использовалась функция std::count.
Из постановки задачи можно без труда вывести тип бинарной функции f, которую нужно передать в алгоритм std::accumulate. Объект типа
std::string представляет собой коллекцию символов, поэтому в роли
типа T должен выступать тип char; поскольку искомая величина есть число символов перевода строки, то типом R должен стать тип int. Следовательно, типом бинарной функции f будет (int, char) → int.
Само собой разумеется, что когда функция f вызывается для первого
символа строки, ее первый аргумент должен иметь значение 0, потому
что в самом начале процесса еще не может быть ни одного подсчитанного
перевода строки. Когда же функция f вызывается на последнем символе
строки, ее результат должен составлять искомое количество. Поскольку

56

Глава 2

Первые шаги в функциональном программировании

функция f не знает, обрабатывает она в данный момент первый, последний символ или какой-либо символ из произвольного места в строке, в ее
реализации никак не должна использоваться позиция символа от начала текста. При каждом вызове функция f знает лишь значение текущего
символа и результат предыдущего вызова этой же функции f. Эти рассуждения позволяют однозначно определить смысл первого аргумента
функции f как число символов перевода строки в уже просмотренной начальной части текста. После этого дальнейшая реализация становится
совершенно тривиальным делом: если текущий символ не есть перевод
строки, функция f должна возвращать в неизменном виде предыдущее
значение счетчика строк, а в противном случае – возвращать значение,
на единицу большее. Конкретный пример такого вычисления показан на
рис. 2.7, а полный текст программной реализации – в следующем лис­
тинге.
Начальное значение

Текст "a\nbc\ndef\n"

Первый символ не есть
перевод строки, поэтому
функция f возвращает
значение 0
Второй символ текста –
перевод строки, поэтому
функция f возвращает значение 1
Третий символ – не перевод
строки, счетчик строк сохраняет
неизменное значение

Всего в тексте найдено три символа
перевода строки

Рис. 2.7 Подсчет строк в заданном тексте посредством свертки по функции,
которая наращивает значение счетчика на единицу всякий раз, когда видит символ
перевода строки

Листинг 2.4 Подсчет символов перевода строки с помощью функции
std::accumulate
int f(int previous_count, char c)
{
return (c != '\n') ? previous_count
: previous_count + 1;
}
int count_lines(const std::string& s)
{

Увеличить счетчик, если текущий
символ – перевод строки

Примеры из библиотеки STL
return std::accumulate(
s.cbegin(), s.cend(),
0,
f
);

57

Провести свертку по всей строке
Начать счет с нуля

}

Можно взглянуть на свертку под иным углом, для этого нужно изменить свое понимание функции f от двух аргументов, передаваемой
в алгоритм std::accumulate. Если рассмотреть ее как обычную левоассоциативную бинарную операцию наподобие операции +, которую можно
использовать в выражении инфиксно, т. е. между операндами, то свертка
оказывается эквивалентной выражению, в котором эта операция помещена между каждой парой соседних элементов коллекции. В примере
с суммированием оценок фильма это означает все оценки в ряд и помещение знаков + между ними (рис. 2.8). Полученное выражение вычисляется слева направо, в точности как выполняет свертку алгоритм
std::accumulate.
Свертка
по операции

с начальным
значением

Свертка
по операции +
с начальным
значением

Рис. 2.8 Свертка по левоассоциативной операции эквивалентна выражению,
которое получится, если выписать все элементы коллекции один за другим и вставить
между каждой парой соседних элементов знак операции

Описанную выше свертку, при которой элементы коллекции обрабатываются начиная с первого, называют левой сверткой. Существует
также правая свертка, при которой обработка начинается с последнего
элемента коллекции и продвигается к ее началу. В инфиксной нотации
правая свертка соответствует вычислению выражения, показанного на
рис. 2.8, если операция обладает правой ассоциативностью, см. также
рис. 2.9. В стандартной библиотеке языка C++ нет отдельного алгоритма
для правой свертки, но нужного поведения легко добиться, если передать в алгоритм std::accumulate обратные итераторы (crbegin и crend).
На первый взгляд свертка может показаться всего лишь сложением
элементов коллекции одного за другим. Но если допустить, что вместо
сложения стоит произвольная бинарная операция, которая может даже
давать результат другого типа, отличного от типа элементов коллекции,
свертка превращается в мощный инструмент для реализации множества
алгоритмов. Конкретный пример этого будет показан далее в данной
главе.

Глава 2

58

Первые шаги в функциональном программировании

Рис. 2.9 Главное различие между левой и правой свертками
состоит в том, что левая свертка начинает с первого элемента коллекции
и продвигается к ее концу, тогда как правая свертка начинает с последнего
элемента и движется к началу коллекции

Несколько слов об ассоциативности
Операция ∇ называется левоассоциативной, если a ∇ b ∇ c = (a ∇ b) ∇ c,
и правоассоциативной, если a ∇ b ∇ c = a ∇ (b ∇ c). С точки зрения математики,
сложение и умножение чисел одновременно лево- и правоассоциативны –
не имеет значения, начинать применение этих операций к списку аргументов с правого или левого конца. Однако в языке C++ обе эти операции определены как левоассоциативные, чтобы правила языка могли гарантировать
определенный порядок вычисления выражений.
Это вовсе не означает в большинстве случаев, будто язык C++ гарантирует
какой-либо порядок вычисления самих аргументов; гарантирован лишь порядок, в котором операция применяется к уже вычисленным значениям. Например, если дано выражение вида a * b * c (где a, b и c – некоторые подвыражения), нельзя сказать, какое из подвыражений будет вычислено первым1,
но точно известен порядок применения операций умножения, а именно:
произведение значений a и b будет умножено на c.

2.2.3 Удаление лишних пробелов
Предположим, дана строка, и необходимо удалить пробелы в ее начале
и на конце. Например, для того, чтобы прочитать строку текста из файла и отобразить ее на экране, центрировав по ширине. Если оставить
1

Стандарт C++17 все же определяет порядок вычисления аргументов в некоторых случаях (см.: Gabriel Dos Reis, Herb Sutter, and Jonathan Caves. Refining
Expression Evaluation Order for Idiomatic C++ // open-std.org. 2016, June 23. URL:
http://mng.bz/gO5J), но для операций наподобие сложения и умножения порядок вычисления аргументов остается неопределенным.

Примеры из библиотеки STL

59

в строке начальные и концевые пробелы, текст может отображаться на
экране со смещением.
В библиотеке STL нет функций для удаления пробелов из начала
и конца строки. Зато она предоставляет вдоволь алгоритмов, на основе
которых нетрудно реализовать такую операцию.
Алгоритм, нужный для данной задачи, – это алгоритм std::find_if. Он
отыскивает в коллекции первый элемент, удовлетворяющий заданному
предикату. В данном случае нужно найти в строке первый символ, не являющийся пробелом. Алгоритм возвращает итератор, указывающий на
искомый элемент (или итератор, указывающий на пустое место после
последнего элемента коллекции, если нужный элемент в коллекции отсутствует). Для того чтобы удалить из строки все начальные пробелы, достаточно удалить из нее элементы с первого до найденного (не включая
его):
std::string trim_left(std::string s)
{
s.erase(s.begin(),
std::find_if(s.begin(), s.end(), is_not_space));
return s;
}

Как обычно, алгоритм поиска принимает пару итераторов, вместе
определяющих коллекцию. Если передать в него обратные итераторы,
он будет искать от конца строки по направлению к ее началу. Таким способом можно удалить пробелы справа:
std::string trim_right(std::string s)
{
s.erase(std::find_if(s.rbegin(), s.rend(), is_not_space).base(),
s.end());
return s;
}

О передаче по значению
В предыдущем примере лучше передавать строку по значению, чем по константной ссылке, потому что функция изменяет свой аргумент и возвращает
результат его модификации. В противном случае пришлось бы внутри функции создавать локальную копию строки. Такая реализация может работать
медленнее, когда функции в качестве аргумента передают временный объект (rvalue), ведь его пришлось бы скопировать, тогда как можно было бы
переместить. Единственный недостаток передачи аргумента по значению
состоит в том, что если конструктор копирования бросит исключение, стек
вызовов может привести автора программы в недоумение1.

1

Более подробные сведения о копировании и перемещении можно найти в работе: Alex Allain. Move Semantics and rvalue References in C++11 // Cprogramming.com. URL: http://mng.bz/JULm.

60

Глава 2

Первые шаги в функциональном программировании

Композиция этих двух функций образует нужную нам функцию trim:
std::string trim(std::string s)
{
return trim_left(trim_right(std::move(s)));
}

Этот пример демонстрирует одно из возможных применений функции высшего порядка std::find_if. Здесь она использована для поиска
первого непробельного символа – сперва с начала строки, а затем с конца. Также показано, как из композиции двух меньших функций получается функция, решающая поставленную задачу.

2.2.4 Разделение коллекции по предикату
Прежде чем погружаться глубже в предмет, рассмотрим еще один пример. Пусть дана коллекция людей, и пусть необходимо переупорядочить
ее так, чтобы все женщины оказались в ее начале. Для этого можно воспользоваться алгоритмом std::partition и его вариацией – алгоритмом
std::stable_partition.
Оба алгоритма принимают на вход коллекцию (как всегда, заданную парой итераторов) и предикат. Они меняют местами элементы
коллекции так, чтобы отделить те их них, что удовлетворяют предикату, от тех, что ему не удовлетворяют. Элементы, для которых предикат истинен, перемещаются ближе к началу коллекции, а в конце
остаются исключительно те элементы, для которых предикат ложен.
Эти алгоритмы возвращают итератор, указывающий на первый элемент из второго сегмента, т. е. на первый элемент, не удовлетворяющий предикату. Этот итератор можно объединить в пару с итератором,
отмечающим начало исходной коллекции, – получится диапазон тех
и только тех элементов исходной коллекции, которые удовлетворяют
предикату; если же объединить его в пару с итератором, указывающим
на конец исходной коллекции, получится диапазон элементов, данный
предикат нарушающих. Это справедливо и в том случае, когда любая
из коллекций пуста.
Различие между этими двумя алгоритмами состоит в том, что функция std::stable_partition сохраняет неизменным порядок расположения
элементов в пределах каждой группы. В следующем примере показан
результат применения алгоритма std::partition: в получившемся списке
Роза стоит перед Мартой, хотя в исходном списке находилась после нее
(рис. 2.10).
Листинг 2.5 Разделение коллекции людей на женщин и мужчин
std::partition(
people.begin(), people.end(),
is_female
);

Примеры из библиотеки STL

61

partition(is_female)
Питер Марта Джейн Дэвид Роза

Том

Роза Марта Джейн Дэвид Питер

Том

Рис. 2.10 Разделение группы людей по предикату, проверяющему, является ли данный
человек женщиной. Все женщины перемещаются в начало коллекции

Хотя следующий пример может показаться несколько надуманным,
представим список элементов пользовательского интерфейса. Пользователь может отметить некоторые элементы и перетащить их в другое
место. Если это место есть начало списка, получаем ту же задачу, что
и в предыдущем примере, только на этот раз в начало списка нужно перемещать не женщин, а выбранные пользователем визуальные элементы. Если выбранные элементы нужно переместить в конец, задача эквивалентна перемещению в начало списка тех элементов, что не выбраны.
Если же выбранные элементы нужно переместить в какое-то место
в середине списка, список можно разбить на две части: перед и после
точки назначения. Тогда в первом списке выбранные элементы нужно
переместить в конец, а во втором – в начало.
Когда пользователь перемещает выбранные объекты, он обычно ожидает, что относительный порядок элементов внутри выбранной группы
останется неизменным. То же требование справедливо и для невыбранных элементов: перемещение нескольких отмеченных пользователем
элементов не должно произвольным образом тасовать остальные. По­
этому здесь нужно пользоваться алгоритмом std::stable_partition вместо
алгоритма std::partition, хотя последний и более эффективен (рис. 2.11).
Листинг 2.6 Перемещение выбранных элементов в заданную точку
std::stable_partition(first, destination, is_not_selected);
std::stable_partition(destination, last, is_selected);

Рис. 2.11 Перемещение выбранных элементов в заданную позицию
с помощью функции std::stable_partition. Выбранные элементы
до точки назначения должны переместиться вниз, а после этой точки – вверх

Глава 2

62

Первые шаги в функциональном программировании

2.2.5 Фильтрация и преобразование
Попытаемся решить задачу, описанную в начале этой главы, с помощью
алгоритмов из библиотеки STL. Напомним: задача состоит в том, чтобы
получить имена всех женщин из заданной группы людей (рис. 2.12).

Джейн

Том

Питер

filter
Джейн
Дэвид

Марта

Рис. 2.12

Роза

Джейн

transform
Марта

Роза

Марта

Роза

Получение имен всех женщин из группы людей

Пусть человек представлен в программе объектом типа person_t,
и пусть в качестве коллекции используется тип std::vector. Для простоты
реализации предположим, что есть функции – не члены класса is_female,
is_not_female и name:
bool is_female(const person_t& person);
bool is_not_female(const person_t& person);
std::string name(const person_t& person);

Как мы уже видели ранее, первая задача состоит в том, чтобы отфильт­
ровать коллекцию и получить вектор, содержащий только женщин. Есть
два способа сделать это с помощью стандартных алгоритмов. Если разрешается модифицировать исходную коллекцию, можно воспользоваться алгоритмом std::remove_if и идиомой «стереть и удалить» (англ. eraseremove), чтобы отбросить из исходной коллекции всех людей, кроме
женщин.
Листинг 2.7 Фильтрация списка путем удаления ненужных элементов
people.erase(
std::remove_if(people.begin(), people.end(),
is_not_female),
people.end());

Удалить выбранные элементы
Отметить элементы для удаления

Идиома «стереть и удалить»
В библиотеке STL, для того чтобы удалить из коллекции все элементы, удовлетворяющие некоторому предикату, или все элементы, имеющие определенное значение,предназначены функции std::remove_if и std::remove.
К сожалению, эти алгоритмы работают с диапазоном, заданным парой итераторов, и ничего не знают о скрывающейся за ними структуре данных, и потому не могут удалить из нее элементы. Эти алгоритмы могут лишь отделить

63

Примеры из библиотеки STL

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

Если же исходную коллекцию менять не хочется – что следует считать
правильным решением, так как мы стремимся, насколько возможно, соблюдать требование чистоты функций, – можно воспользоваться функцией
std::copy_if, чтобы скопировать все элементы, удовлетворяющие условию
фильтрации, в новую коллекцию. Этому алгоритму нужно передать пару
итераторов, определяющих входную коллекцию, один итератор, указывающий на коллекцию, в которую нужно копировать элементы, и предикат,
выделяющий элементы, подлежащие копированию. Поскольку число женщин в исходной коллекции заранее неизвестно (его можно приблизительно оценить, основываясь на данных статистики, но это выходит за рамки
данного примера), нужно создать пустой вектор females и использовать
итератор std::back_inserter(females) в качестве точки назначения.
Листинг 2.8 Фильтрация коллекции путем копирования элементов
в новую коллекцию
std::vector females;
std::copy_if(people.cbegin(), people.cend(),
std::back_inserter(females),
is_female);

Создать новую коллекцию для сохранения
отфильтрованных элементов
Копировать элементы,
удовлетворяющие условию,
в новую коллекцию

Следующий шаг – получить имена людей из отфильтрованной коллекции. Для этого можно воспользоваться функцией std::transform. Ей нужно передать входную коллекцию в виде пары итераторов, функцию-преобразователь и итератор, указывающий место для хранения результатов.
На этот раз известно, что имен в результирующей коллекции будет ровно
столько же, сколько женщин было в исходной коллекции, поэтому можно сразу создавать вектор names требуемого размера, а в качестве точки
назначения вместо итератора std::back_inserter использовать итератор
names.begin(). Это позволяет избежать повторного выделения памяти, которое происходит при увеличении размера вектора.
Листинг 2.9

Получение имен

std::vector names(females.size());
std::transform(females.cbegin(), females.cend(),
names.begin(),
name);

Исходная коллекция
для преобразования
Куда записывать результаты
Функция-преобразователь

64

Глава 2

Первые шаги в функциональном программировании

Таким образом, крупная задача разбита на две более мелкие. Вместо
того чтобы создавать одну узкоспециализированную функцию, пригодную лишь для одной конкретной задачи, мы создали две отдельные, потенциально применимые для гораздо более широкого круга задач: одна
фильтрует коллекцию людей по некоторому предикату, а другая получает имена всех людей из заданной коллекции. Такой код гораздо лучше
подходит для многократного использования.

2.3 Проблема композиции алгоритмов
из библиотеки STL
Решение, представленное в предыдущем разделе, корректно в том смысле, что правильно работает для любого типа входной коллекции, лишь
бы к ней можно было обращаться посредством итераторов, от векторов
и списков до множеств, хеш-таблиц и деревьев. Кроме того, код ясно
выражает смысл программы: скопировать из исходной коллекции всех
женщин в отдельную коллекцию, затем из нее получить все имена.
К сожалению, этот подход не столь эффективен и лаконичен, как следующий самодельный цикл:
std::vector names;
for (const auto& person : people) {
if (is_female(person)) {
names.push_back(name(person));
}
}

Реализация на основе библиотеки STL без необходимости копирует
объекты, описывающие людей (такая операция может оказаться дорогостоящей или вообще невозможной, если конструктор копирования
удален или скрыт), а также создает дополнительный вектор для промежуточных данных, на самом деле ненужный. Можно попытаться обойти
эти проблемы, если вместо копирования использовать ссылки или указатели либо создать умный итератор, который пропускает людей, не являющихся женщинами, или иными способами. Однако необходимость
в таких ухищрениях, требующих дополнительной работы, ясно указывает, что в данном случае библиотека STL проигрывает. Написанный свои­
ми руками узкоспециализированный цикл работает лучше и требует
меньших усилий.
В чем же корень проблемы? Вспомним сигнатуры наших функций
transform и filter. Они продуманы так, чтобы поддерживать композицию. Одну из них можно применять к результату другой:
filter : (collection, (T → bool)) → collection
transform : (collection, (T → T2)) → collection
transform(filter(people, is_female), name)

Проблема композиции алгоритмов из библиотеки STL

65

Алгоритмы std::copy_if и std::transform не подходят под эти сигнатуры. Они требуют тех же данных на вход, но существенно иным способом.
Входную коллекцию они принимают в виде пары итераторов, что делает
невозможным применение одной из этих функций к коллекции, которую
создает другая, без сохранения этой промежуточной коллекции в отдельную переменную. Вместо того чтобы возвращать коллекцию – результат
фильтрации или преобразования, они требуют, чтобы им на вход в качест­
ве аргумента передали итератор по этой коллекции. В качестве результата
эти алгоритмы возвращают итератор вывода, указывающий в коллекцииприемнике на элемент, следующий после последнего вставленного:
OutputIt copy_if(InputIt first, InputIt last,
OutputIt destination_begin,
UnaryPredicate pred);
OutputIt transform(InputIt first, InputIt last,
OutputIt destination_begin,
UnaryOperation transformation);

Это исключает всякую возможность сочленять данные алгоритмы без
создания промежуточных переменных, что и видно из предыдущего
примера.
Хотя это и может показаться огрехом проектирования библиотеки,
которого нужно было избежать, для такого решения, не­смот­ря на все
связанные с ним проблемы, есть практические причины. Во-первых,
передача коллекции в виде пары итераторов позволяет применять алгоритмы не только к коллекции целиком, но и к ее части. Кроме того, передача итератора вывода в качестве аргумента вместо возврата коллекции
позволяет делать тип коллекции-результата отличным от типа исходной
коллекции. Например, если нужно получить все различные имена женщин, в качестве итератора вывода можно передать итератор по контейнеру типа std::set.
Возврат алгоритмом итератора, указывающего в коллекции-приемнике на элемент, следующий после последнего вставленного, тоже имеет
свои преимущества. Скажем, если нужно создать массив из тех же людей, что и в исходной коллекции, переупорядоченных таким образом,
чтобы первыми в нем находились женщины (то есть сделать примерно
то же, что и алгоритм std::stable_partition, но с созданием новой коллекции вместо изменения исходной), достаточно просто вызвать функцию
std::copy_if дважды: в первый раз скопировать всех женщин, а за второй
вызов – всех прочих. Первый вызов вернет итератор, указывающий на
позицию, с которой должен начинать вставку элементов второй вызов.
Листинг 2.10

Разделение списка

std::vector separated(people.size());
const auto last = std::copy_if(
people.cbegin(), people.cend(),
separated.begin(),

Возвращает позицию после последнего
вставленного элемента

66

Глава 2

Первые шаги в функциональном программировании

is_female);
std::copy_if(
people.cbegin(), people.cend(),
last,
is_not_female);

Новые элементы будут вставлены после женщин

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

2.4

Создание своих функций высшего порядка
В библиотеке STL и свободно распространяемых сторонних библиотеках, таких как Boost, реализовано множество алгоритмов, однако часто
возникает необходимость реализовать самостоятельно какие-либо алгоритмы, специфические для той или иной предметной области. Иног­
да бывает нужна специализированная версия стандартного алгоритма,
в других случаях требуется воплотить что-то особенное полностью самостоятельно.

2.4.1 Передача функции в качестве аргумента
В предыдущем примере нужно было получить имена всех женщин из
заданной коллекции. Предположим теперь, что имеется коллекция людей и что часто возникает потребность получить имена тех из них, кто
удовлетворяет некоторому условию, но в этот раз мы не хотим ограничивать себя заранее фиксированным условием наподобие is_female. Вместо
этого нужна возможность работать с любым предикатом, принимающим
аргумент типа person_t. Так, пользователь может выделять людей по возрасту, цвету волос, семейному положению и т. д.
Для этого было бы полезно сделать единую функцию, которую можно
вызывать для всего множества таких задач. Эта функция должна принимать вектор людей и функцию-предикат для фильтрации, а возвращать
вектор строк, содержащий имена людей, удовлетворяющих предикату.
Данный пример может показаться чересчур узким. Было бы гораздо
полезнее, если бы функция могла работать с любым типом коллекции
на входе и на выходе, чтобы не быть ограниченной исключительно векторами людей. Также было бы лучше, если бы функция могла выделять
любые данные о человеке, а не только имя. Читатель может сделать код
более обобщенным, но мы стремимся показать простое решение, чтобы
сфокусировать внимание на самом важном.
Очевидно, что вектор людей должен передаваться по константной
ссылке, но как быть с аргументом-функцией? Можно воспользовать-

Создание своих функций высшего порядка

67

ся указателем на функцию, но это накладывало бы слишком жесткие
ограничения. В языке C++ многие сущности могут вести себя подобно
функциям, а использование универсального типа, охватывающего все
такие сущности, неизбежно влечет за собой потерю производительности. Поэтому, вместо того чтобы гадать, какой тип лучше всего подойдет
аргументу-функции, можно сделать тип функции параметром шаблона,
и пускай компилятор сам определяет конкретный тип.
template
std::vector names_for(
const std::vector& people,
FilterFunction filter);

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

2.4.2 Реализация на основе циклов
В предыдущих разделах было показано, как реализовать функцию names_
for на основе алгоритмов из библиотеки STL. Хотя обычно рекомендуется использовать средства стандартной библиотеки всюду, где это возможно, это правило не следует считать абсолютным. При желании его
можно нарушать, только для этого нужно иметь вескую причину и быть
заранее готовым к проникновению в код большего числа ошибок. В данном конкретном случае из-за того, что использование стандартных алгоритмов требует лишних операций по выделению динамической памяти и копированию промежуточных данных, вполне оправданным будет
реализовать предыдущий пример своими руками, на основе цикла, см.
листинг 2.11.

Призвать на помощь диапазоны из библиотеки ranges
Проблема ненужных операций выделения памяти проистекает из недостаточной пригодности алгоритмов из стандартной библиотеки к композициям.
Эта проблема хорошо известна на протяжении некоторого времени, и для ее
решения создан ряд библиотек.
В главе 7 понятие диапазонов (ranges) рассматривается подробно. В настоящее время поддержка диапазонов опубликована в виде технической специ­
фикации и планируется к включению в стандарт C++20. До тех пор, пока
диапазоны не стали частью стандартной библиотеки, они доступны в виде
сторонней библиотеки, которую можно использовать с большинством компиляторов, совместимых со стандартом C++11.
С помощью диапазонов программист может добиться того, чтобы волки были
сыты и овцы целы, создавая мелкие функции и сочленяя их между собой без
какого бы то ни было ущерба для производительности.

Глава 2

68

Листинг 2.11

Первые шаги в функциональном программировании

Реализация функции своими руками на основе цикла

template
std::vector names_for(
const std::vector& people,
FilterFunction filter)
{
std::vector result;
for (const person_t& person : people) {
if (filter(person)) {
result.push_back(name(person));
}
}
return result;
}

В том, что столь простая функция вручную реализована на основе цикла, большой беды нет. Имени функции и ее параметров довольно, чтобы
ее предназначение стало очевидным. Большая часть алгоритмов в биб­
лиотеке STL реализована в виде циклов, подобно этой функции.
Но если сами стандартные алгоритмы реализованы в виде циклов, что
же плохого в том, чтобы в своих программах реализовывать все циклами? Зачем вообще утруждать себя изучением библиотеки STL?
Для этого есть несколько причин. Первая – это простота. Использование
кода, который кто-то другой уже написал ранее, экономит время. Этим
обусловлена вторая выгода – корректность. Если одну и ту же идею алгоритма приходится воплощать снова и снова, естественно ожидать, что
когда-нибудь программист допустит ошибку. Алгоритмы из библиотеки
STL тщательно протестированы и гарантированно работают корректно на
любых входных данных. По этой же причине наиболее часто используемые функции в своей программе можно реализовывать самостоятельно
через циклы: эти функции наверняка будут тестироваться нередко.
Хотя многие алгоритмы в библиотеке STL нельзя назвать чистыми,
они оформлены в виде функций высшего порядка, что делает их более
общими и расширяет сферу их применения. А чем чаще используется
функция, тем меньше вероятность найти в ней незамеченную ранее
ошибку.

2.4.3 Рекурсия и оптимизация хвостового вызова
Предыдущее решение выглядит чистым со стороны, но его реализация
таковой не является. Функция модифицирует вектор result всякий раз,
когда находит в исходной коллекции человека, удовлетворяющего критерию. В чистых функциональных языках, где нет никаких циклов, функции для линейного просмотра коллекций обычно бывают реализованы
посредством рекурсии. Здесь мы не будем погружаться в данную тему
слишком глубоко, поскольку программисту на языке C++ вряд ли придется пользоваться ею часто, но некоторые важные аспекты осветить нужно.

Создание своих функций высшего порядка

69

Чтобы рекурсивно обработать непустой вектор, нужно сначала обработать его голову (т. е. первый элемент), а дальше тем же самым алгоритмом обработать хвост (все остальные элементы, кроме первого), который тоже можно рассматривать как вектор. Если голова удовлетворяет
предикату, ее нужно прибавить к коллекции результатов. Наконец, если
на вход алгоритма приходит пустой вектор исходных данных, он должен
вернуть пустой вектор результатов.
Допустим, в нашем распоряжении есть функция tail, которая принимает на вход вектор и возвращает его хвост. Также предположим, что
дана функция prepend, которая принимает одиночное значение и вектор,
а возвращает новый вектор, полученный из исходного вставкой нового
элемента в начало.
Листинг 2.12 Наивная рекурсивная реализация
template
std::vector names_for(
const std::vector& people,
FilterFunction filter)
{
Если коллекция пуста,
if (people.empty()) {
вернуть пустой результат
return {};
} else {
const auto head = people.front();
const auto processed_tail = names_for(
tail(people),
filter);

Вызвать эту
же функцию
рекурсивно,
чтобы обработать
хвост коллекции

if (filter(head)) {
return prepend(name(head), processed_tail);
} else {
return processed_tail;
}

Если первый элемент
удовлетворяет предикату,
добавить его к результату.
Иначе пропустить элемент

}
}

Эта реализация неэффективна. Во-первых, есть причина, почему
в стандартной библиотеке отсутствует функция tail для векторов: она
должна была бы создать новый вектор и скопировать в него все элементы
исходного вектора, за исключением первого. Проблему с функцией tail
легко решить, если вместо вектора использовать в качестве аргументов
пару итераторов. В этом случае получение хвоста становится тривиальным делом: достаточно увеличить на единицу итератор, отмечающий
начало коллекции.
Листинг 2.13

Рекурсивная реализация

template
std::vector names_for(
Iterator people_begin,

Глава 2

70

Первые шаги в функциональном программировании

Iterator people_end,
FilterFunction filter)
{
…
const auto processed_tail = names_for(
people_begin + 1,
people_end,
filter);
…
}

Второй недостаток этой реализации состоит в том, что новые элементы добавляются в начало вектора. С этим трудно что-либо поделать.
Похожая ситуация имела место и в циклической реализации, хотя там
элементы добавлялись в конец, что в случае вектора более эффективно.
Последняя и, пожалуй, самая важная проблема проявляется в том
случае, если функция применяется к очень большой коллекции элементов. Каждый рекурсивный вызов потребляет память на стеке, поэтому
в некоторый момент времени стек окажется переполнен, и программа
аварийно завершится. Даже если коллекция недостаточно велика, чтобы
вызвать переполнение стека, вызовы функций не бесплатны; простые
машинные команды перехода, в которые компилятор превращает цикл
for, работают гораздо быстрее.
Хотя все предыдущие проблемы можно решить относительно легко,
с этой последней так просто не справиться. Программисту остается лишь
надеяться, что компилятор сумеет преобразовать рекурсию в цикл. Для
того чтобы это произошло, необходимо использовать особую форму рекурсии, называемую хвостовой. При хвостовой рекурсии вызов функцией самой себя должен быть последним, что функция делает: функция не
должна ничего делать с результатом рекурсивного самовызова.
В предыдущем примере рекурсия не хвостовая, поскольку функция,
получив результат самовызова, применяет к нему еще одну операцию:
если выражение filter(head) дает значение true, добавляет к нему новый
элемент и лишь затем возвращает полученную коллекцию в качестве
своего результата. Преобразование произвольной рекурсии в хвостовую
не так тривиально, как предыдущие усовершенствования. Поскольку
теперь функция должна возвращать окончательный результат, нужно
найти иной способ накопления промежуточных результатов. Для этого
понадобится дополнительный аргумент, который нужно передавать от
вызова к вызову рекурсивной функции.
Листинг 2.14

Реализация на основе хвостовой рекурсии

template
std::vector names_for_helper(
Iterator people_begin,
Iterator people_end,
FilterFunction filter,
std::vector previously_collected)
{
if (people_begin == people_end) {

Создание своих функций высшего порядка

71

return previously_collected;
} else {
const auto head = *people_begin;
if (filter(head)) {
previously_collected.push_back(name(head));
}
return names_for_helper(
people_begin + 1,
people_end,
filter,
std::move(previously_collected));
}
}

Теперь функция возвращает либо ранее вычисленное значение, либо
в точности то значение, которое возвращает рекурсивный вызов. Единственное неудобство состоит в том, что для вызова этой функции нужен
один дополнительный аргумент. Именно поэтому функция получила имя
names_for_helper (англ. «вспомогательная»); ту же функцию, что нужна пользователю, можно реализовать тривиально, вызвав вспомогательную функцию и передав ей пустой вектор в качестве параметра previously_collected.
Листинг 2.15 Вызов вспомогательной функции
template
std::vector names_for(
Iterator people_begin,
Iterator people_end,
FilterFunction filter)
{
return names_for_helper(people_begin,
people_end,
filter,
{});
}

В этом случае компиляторы, поддерживающие оптимизацию хвос­
товых вызовов (tail-call optimization, TCO), получат возможность преобразовать рекурсивную функцию в обычный цикл и сделать ее столь
же эффективной, как и код, с которого начинался разбор этого примера
(листинг 2.11).
ПРИМЕЧАНИЕ Стандарт языка C++ не дает никаких гарантий
того, что оптимизация хвостовых вызовов будет произведена.
Однако большинство современных компиляторов, включая GCC,
Clang и MSVC, поддерживают ее. Иногда они даже умеют оптимизировать взаимно рекурсивные вызовы (то есть такие, когда
функция f вызывает функцию g, а та, в свою очередь, вызывает f)
и некоторые функции, в которых рекурсия, строго говоря, не хвос­
товая, но достаточно близка к ней.

Powered by TCPDF (www.tcpdf.org)

72

Глава 2

Первые шаги в функциональном программировании

Рекурсия предоставляет мощный механизм для реализации итеративных алгоритмов в языках, не имеющих оператора цикла. Однако рекурсия – это все же довольно низкоуровневая конструкция. С ее по­мощью
можно добиться полной чистоты внутренней реализации функций, но
во многих случаях это не так уж и нужно. Как было сказано выше, к чис­
тоте стремятся для того, чтобы делать меньше ошибок при написании
кода, избавившись от необходимости держать в голове изменяемое состояние. Однако при написании хвостовых рекурсий наподобие той, что
представлена в листинге 2.14, программист имитирует изменяемое состояние и циклы, только иными средствами. Это хорошее упражнение
для ума, но вряд ли что-то большее.
У рекурсий, как и у написания циклических алгоритмов своими руками, есть своя ниша. Но в большинстве случаев при рецензировании
кода на языке C++ она должна служить сигналом тревоги. Нужно тщательно проверять ее корректность и убеждаться в том, что при всех возможных способах использования функции не произойдет переполнение стека.

2.4.4 Реализация на основе свертки
Поскольку рекурсия относится к конструкциям сравнительно низкого
уровня, реализации рекурсивных функций своими руками часто стараются избегать даже в чистых языках функционального программирования. Можно даже сказать, что конструкции высокого уровня именно
потому столь популярны в функциональном программировании, что
рекурсия слишком замысловата.
Выше читатель уже видел, что такое свертка, но по-настоящему глубоко это понятие пока не рассматривалось. Свертка каждый раз берет
один элемент коллекции и применяет заданную функцию к ранее накопленному промежуточному результату и этому текущему значению,
вырабатывая тем самым новое промежуточное значение. Читатели,
внимательно прочитавшие предыдущий раздел, наверняка заметили, что это – в точности то, что делала хвостовая рекурсивная функция
names_for_helper из листинга 2.14. В сущности, свертка есть не что иное,
как более изящный способ создания хвостовых рекурсивных функций
для обработки коллекций. Свертка позволяет абстрагироваться от общей
части реализации, программисту остается задать лишь саму коллекцию,
начальное значение и аккумулирующую операцию – без необходимости
каждый раз своими руками писать рекурсию.
Если читателю захочется реализовать функцию names_for на основе
свертки (в стандартной библиотеке получившей имя std::accumulate), это
можно легко сделать теперь, когда изучена ее реализация через хвостовую рекурсию. Нужно начать с пустого вектора строк и добавлять к нему
новое имя всякий раз, когда очередной элемент коллекции удовлетворяет предикату, только и всего.

Создание своих функций высшего порядка

Листинг 2.16

73

Реализация на основе свертки

std::vector append_name_if(
std::vector previously_collected,
const person_t& person)
{
if (filter(person)) {
previously_collected.push_back(name(person));
}
return previously_collected;
}
…
return std::accumulate(
people.cbegin(),
people.cend(),
std::vector{},
append_name_if);

Слишком много копий
Если запустить функцию из листинга 2.16 на достаточно большой коллекции, можно заметить, что она работает медленно. Причина состоит
в том, что функция append_name_if получает вектор-аргумент по значению,
а это означает создание новой копии вектора всякий раз, когда функция
std::accumulate вызывает функцию append_name_if и передает ей ранее накопленный результат.
Создание копии при каждом вызове оказывается в этом случае ненужной
пессимизацией, которая будет исправлена в стандарте C++20. До выхода нового стандарта программист может пользоваться собственной версией алгоритма std::accumulate, в которой для передачи накопленного значения применяется семантика перемещения вместо копирования (именно так будет
работать алгоритм std::accumulate в стандарте C++20). Реализацию функции
moving_accumulate можно найти в примерах кода к этой книге.

Свертка – это мощный инструмент. Читатель имел возможность убедиться, что он достаточно выразителен, чтобы на его основе воплотить
подсчет элементов, поэлементное преобразование (часто обозначаемое
transform или map) и фильтрацию (в последнем примере реализована комбинация алгоритмов transform и filter). С помощью свертки можно реализовать немалую часть стандартных алгоритмов. Интересным упражнением может послужить реализация таких алгоритмов, как std::any_of,
std::all_of и std::find_if на основе функции std::accumulate. При этом
стоит проверить, работают ли эти реализации столь же быстро, как и исходные алгоритмы, а если они окажутся медленнее, выяснить, почему.
Еще один алгоритм, который может стать превосходным упражнением
на применение свертки, – это сортировка вставками.

Глава 2

74

Первые шаги в функциональном программировании

СОВЕТ Более подробную информацию и ссылки по темам, затронутым в этой главе, можно найти на странице https://forums.manning.com/posts/list/41681.page.

Итоги
Передавая свои предикаты и функции в такие алгоритмы, как transform
и filter, можно настраивать поведение этих обобщенных алгоритмов
так, чтобы они решали конкретную прикладную задачу.
„„ Хотя алгоритм std::accumulate находится в заголовочном файле , его можно применять к гораздо более широкому кругу задач, чем
чисто арифметические вычисления.
„„ Алгоритм std::accumulate реализует понятие свертки, которое не ограничивается сложением или перемножением элементов и на основе
которого можно построить множество стандартных алгоритмов.
„„ Если хочется сохранить неизменным порядок элементов при их
перемещении по контейнеру, следует пользоваться алгоритмом
std::stable_partition вместо более быстрого std::partition. По этой же
причине, в особенности в задачах, касающихся визуального интерфейса пользователя, алгоритм std::stable_sort часто бывает предпочтительнее, чем std::sort.
„„ Хотя алгоритмы из стандартной библиотеки разрабатывались так,
чтобы их можно было состыковывать между собой, они поддерживают
композицию совсем не в том виде, как она выглядит в чисто функциональных языках. Этот недостаток легко устранить, если использовать
диапазоны (ranges).
„„ То обстоятельство, что большая часть стандартных алгоритмов обработки коллекций реализована в виде циклов, отнюдь не означает, что
программисту следует собственными руками писать циклы. Подобным образом, хотя операторы while, if и другие реализуются на основе
команд перехода, программисты, как правило, не используют в своем
коде операторы goto по хорошо известным причинам.
„„

3

Функциональные объекты

О чем говорится в этой главе:

различные сущности в языке C++, которые можно использовать
в роли функций;
„„ создание обобщенных функциональных объектов;
„„ что такое лямбда-выражения и как они соотносятся с обычными функциональными объектами;
„„ создание изящных функциональных объектов с помощью биб­
лиотеки Boost.Phoenix и своими руками;
„„ что такое тип std::function и когда его стоит использовать.
„„

В предыдущей главе читатель увидел, как определять функции, способные принимать другие функции в качестве своих аргументов. Теперь
пришло время заняться другой стороной медали – изучить все виды
сущностей, которые можно использовать в языке C++ в роли функций.
Тема может показаться не слишком увлекательной, но ее необходимо
разобрать, чтобы глубже понять суть функций в языке C++ и достичь
заветной цели – научиться использовать высокоуровневые абстракции, не жертвуя при этом производительностью. Всякому, кто желает
сполна воспользоваться всей мощью языка C++ в своем путешествии
в мир функционального программирования, нужно хорошо знать все те
«вещи», которые язык C++ позволяет рассматривать как функции, каким
из них отдавать предпочтение, а каких избегать.
Если воспользоваться метафорой утиной типизации («если это выглядит как утка, плавает как утка и крякает как утка, то это, вероятно,
и есть утка»), можно дать такую формулировку: все, что можно вызвать

76

Глава 3

Функциональные объекты

подобно функции, есть функциональный объект. Более конкретно, если
можно написать имя некоторой сущности, а вслед за ним указать аргументы в скобках, т. е. составить выражение вида f(arg1, arg2, …, argn), эта
сущность является функциональным объектом. В данной главе мы рассмотрим все виды сущностей, которые в языке C++ рассматриваются как
функциональные объекты.
Чтобы отличать обычные функции языка C++ от всех тех вещей, которые могут использоваться в роли функций, будем называть последние
функциональными объектами в случаях, когда требуется явно провести
такое различие.

3.1

Функции и функциональные объекты
Функция – это именованная группа операторов, которую можно вызывать из других частей программы или из самой этой функции (в этом
случае функция будет рекурсивной). Язык C++ предоставляет два различных способа записать определение функции:
int max(int arg1, int arg2) { … }
auto max(int arg1, int arg2) -> int { … }

Старый синтаксис, унаследованный
от языка C
Новый синтаксис с возвращаемым
типом в конце

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

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

3.1.1 Автоматический вывод возвращаемого типа
Начиная со стандарта C++14 разрешается опускать возвращаемый тип
и поручать компилятору его автоматический вывод, исходя из выраже-

Функции и функциональные объекты

77

ния, использованного в операторе return. Вывод типа в этом случае осуществляется по тем же правилам, что и вывод типов-аргументов шаб­лона.
В следующем примере объявлена целочисленная переменная answer
и две функции, ask1 и ask2. Эти функции обладают одинаковым телом –
они просто возвращают переменную answer. Но возвращаемый тип у них
объявлен по-разному. Первая функция возвращает значение, чей тип выводится автоматически, тогда как вторая возвращает константную ссылку
на нечто, чей тип выводится автоматически. В обоих случаях компилятор
посмотрит на тип переменной answer, к которой применяется оператор
return, обнаружит, что это тип int, и заменит им ключевое слово auto.
int answer = 42;
auto ask1() { return answer; }
const auto& ask2() { return answer; }

Возвращаемый тип – int
Возвращаемый тип – const int&

Хотя правила вывода типов-аргументов шаблона (и, следовательно,
вывод возвращаемого типа) на самом деле сложнее, чем «просто заменить слово auto известным типом», в целом они работают интуитивно
понятным образом, поэтому мы не будем рассматривать их здесь1.
Если в теле функции имеется несколько операторов return, все они
должны возвращать значения одного типа. Если их типы различаются,
компилятор сообщит об ошибке. В следующем фрагменте кода показана
функция, которая принимает на вход логическое значение (флаг) и, в зависимости от его истинности или ложности, возвращает значение типа
int или типа std::string. Компилятор отвергнет этот код, потому что из
первого оператора return будет выведен целочисленный тип, а для второй оператор возвращает значение иного типа:
auto ask(bool flag)
{
if (flag) return 42;
else
return std::string("42");
}

Ошибка – не совпадают выведенные типы
возвращаемого значения: int и std::string

После того как тип возвращаемого значения выведен, его можно использовать в оставшейся части функции. Это позволяет создавать рекурсивные функции с автоматически выведенным типом, как показано
в следующем примере:
auto factorial(int n)
{
Тип результата
if (n == 0) {
выводится как int
return 1;
} else {
return factorial(n - 1) * n;
}
}
1

Уже известно, что функция factorial
возвращает значение типа int,
а умножение двух чисел типа int дает
результат типа int, поэтому все в порядке

Подробное изложение правил автоматического вывода типов-аргументов шаб­
лона можно найти в справочнике по языку C++: http://mng.bz/YXIU.

78

Глава 3

Функциональные объекты

Если переставить местами ветки if и else, получится ошибка компиляции, поскольку компилятор встретит рекурсивный вызов функции factorial до того, как этот тип будет выведен. При написании рекурсивных
функций нужно либо в явном виде указать возвращаемый тип, либо первым разместить тот оператор return, который не содержит рекурсивного
вызова.
Помимо ключевого слова auto, которое означает, что для типа возвращаемого значения будут использованы те же правила вывода, что и для
типов-аргументов шаблона, можно в качестве возвращаемого типа использовать также конструкцию decltype(auto). В этом случае возвращаемым типом функции будет тип decltype самого возвращаемого выражения. Проиллюстрируем это примером:
decltype(auto) ask() { return answer; }
decltype(auto) ask() { return (answer); }
decltype(auto) ask() { return 42 + answer; }

Возвращаемый тип decltype(answer) есть int

Возвращаемый тип
decltype(42 + answer) есть int

Возвращаемый тип
decltype((answer)) есть ссылка на
int, тогда как с ключевым словом
auto был бы выведен тип int

Это может пригодиться при написании шаблона функции высшего
порядка, которая возвращает без изменений результат другой функции,
переданной в качестве аргумента. В этом случае неизвестно заранее,
какого типа функция будет передана, поэтому неизвестно, нужно ли ее
результат отдавать наружу по значению или по ссылке. Если отдавать по
ссылке результат функции, возвращающей значение, будет возвращена
ссылка на временный объект, что приведет к неопределенному поведению. Если же передать наружу по значению результат функции, вернувшей ссылку, это приведет к созданию временной копии. Копирование
может ухудшить быстродействие кода и иногда оказывается просто семантически неверным – ведь вызывающий код может требовать именно
ссылку на объект-оригинал.
Поэтому для идеальной передачи из функции наружу результата, возвращенного другой функцией (т. е. для того, чтобы результат внутренней
функции вернуть без каких бы то ни было изменений), нужно использовать конструкцию decltype(auto) в качестве спецификации возвращаемого типа, как показано в следующем примере:
template
decltype(auto) call_on_object(Object&& object, Function function)
{
return function(std::forward(object));
}

В этом небольшом примере рассмотрен простой шаблон функции,
принимающий два аргумента: объект и функцию, которая должна быть
применена к этому объекту. Объект object идеально передается в функцию function в качестве аргумента – благодаря использованию специальной функции std::forward; а за счет спецификации возвращаемого типа

Функции и функциональные объекты

79

конструкцией decltype(auto) результат функции function идеально передается в контекст, вызвавший функцию call_on_object.

Идеальная передача аргументов
Иногда бывает нужно создавать функции, играющие роль оберток для
других функций. Единственное, что должна делать такая функция, – это
вызывать обертываемую функцию, возможно, модифицируя, добавляя
или устраняя некоторые из ее аргументов. В этом случае возникает вопрос: как аргументы функции-обертки передавать в ту функцию, которую она вызывает?
В ситуациях, подобных той, что описана в предыдущем примере, вызывающий контекст передает функцию, о которой обертка ничего не
знает. Автор обертки, в частности, не может знать, какого способа передачи аргументов она ожидает.
Одно возможное решение состоит в том, чтобы функция-обертка
call_on_object принимала аргумент object по значению и передавала
его в обернутую функцию. Это, однако, приведет к проблемам в случае,
если обертываемая функция ожидает ссылку на объект, для того чтобы
модифицировать его. Внесенное в объект изменение не будет видно за
пределами функции call_on_object, поскольку изменению подвергается
локальная копия объекта, существующая только внутри функции call_
on_object.
template
decltype(auto) call_on_object(Object object,
Function function)
{
return function(object);
}

Вторая возможность состоит в том, чтобы передавать объект по ссылке. Это сделает изменения, вносимые в объект, видимыми для кода, вызывающего функцию call_on_object. Но теперь проблема возникает в случае, когда обертываемая функция function не собирается изменять объект
и принимает аргумент по константной ссылке. Вызывающий код окажется не в состоянии применить функцию call_on_object на константном
объекте или на временном значении. Поэтому идея принимать аргумент
object по обычной ссылке не подходит. Сделать эту ссылку константной
тоже не получается, потому что некоторые обертываемые функции могут все же модифицировать объект-аргумент.
В некоторых библиотеках, разработанных до выхода стандарта C++11,
с этой трудностью боролись, создавая перегрузки для обоих видов ссылок: константных и неконстантных. Это непрактично, так как число необходимых перегрузок растет экспоненциально с ростом числа аргументов, которые нужно передавать в обертываемую функцию.
В языке C++11 проблема решается с помощью пересылающих ссылок
(forwarding references), также известных под названием универсальных

Глава 3

80

Функциональные объекты

ссылок1 (universal references). Пересылающая ссылка обозначается двумя знаками ссылки, примененными к типу-параметру шаблона. В следующем примере аргумент fwd представляет собой пересылающую
ссылку на объект типа T, тогда как аргумент value – это обычная ссылка
rvalue:
template
void f(T&& fwd, int&& value) { … }

Пересылающая ссылка позволяет принимать константные, неконстантные и временные объекты. Теперь фунции-обертке остается лишь
передать этот аргумент в обертываемую функцию, причем сделать это
нужно, сохранив ту же категорию выражения, по которой данный аргумент был получен. Именно это делает функция std::forward.

3.1.2 Указатели на функции
Если переменная имеет тип указателя на функцию, это значит, что в ней
хранится адрес, по которому функция расположена в памяти и по которому эту функцию можно позднее вызвать. Язык C++ унаследовал эту
весьма низкоуровневую конструкцию от языка C для поддержки полиморфного кода. Полиморфизм времени выполнения достигается за счет
того, что в переменную можно подставлять адрес то одной, то другой
функции, тем самым меняя поведение кода, вызывающего функцию по
указателю.
Указатели и ссылки на функции являются функциональными объектами, поскольку их можно вызывать так же, как и обычные функции.
Помимо того, и все типы, допускающие неявное преобразование к типу
указателя на функцию, также являются функциональными объектами,
хотя пользоваться этим приемом в своих программах не рекомендуется.
Вместо этого лучше пользоваться функциональными объектами в узком
смысле (о них речь пойдет вскоре), у которых и возможности шире, и обращаться с ними удобнее. Объекты, поддерживающие преобразование
в указатели на функции, могут быть полезны разве что в случаях, когда
нужно взаимодействовать с кодом, написанным на языке C, умеющим
принимать лишь указатели на функции, а приложению нужно передавать в него нечто более сложное, чем просто функцию.
Следующий пример иллюстрирует вызов через указатель на функцию, ссылку на функцию и объект, преобразующийся в указатель на
функцию.
int ask() { return 42; }
typedef decltype(ask)* function_ptr;
class convertible_to_function_ptr {
1

Название дано Скоттом Мейерсом в работе «Universal References in C++11»
(Stan­dard C++ Foundation, Nov. 1, 2012), доступной по ссылке http://mng.bz/Z7nj.

Функции и функциональные объекты
public:
operator function_ptr() const
{
return ask;
}
};
int main(int argc, char* argv[])
{
auto ask_ptr = &ask;
std::cout