Обратные вызовы в C++

Оглавление

Виталий Евгеньевич Ткаченко. Обратные вызовы в C++

Введение

1. Теоретические основы обратных вызовов

1.1. Концепция обратных вызовов

1.1.1. Интуитивное определение

1.1.2. Обратный вызов как паттерн

1.1.3. Прямые и обратные вызовы

1.2. Задачи, решаемые с помощью обратных вызовов

1.2.1. Запрос данных

1.2.2. Вычисления по запросу

1.2.3. Перебор элементов

1.2.4. Уведомление о событиях

1.3. Модель обратных вызовов

1.3.1. Определения и термины

1.3.2. Контекст

1.4. Архитектурный дизайн вызовов

1.4.1. Синхронные и асинхронные вызовы

1.4.2. Использование вызовов в API

1.5. Итоги

2. Реализация обратных вызовов

2.1. Указатель на функцию

2.1.1. Концепция

2.1.2. Инициатор

2.1.3. Исполнитель

2.1.4. Синхронный вызов

2.1.5. Преимущества и недостатки

2.2. Указатель на статический метод класса

2.2.1. Концепция

2.2.2. Инициатор

2.2.3. Исполнитель

2.2.4. Синхронный вызов

2.2.5. Преимущества и недостатки

2.3. Указатель на метод-член класса

2.3.1. Концепция

2.3.2. Инициатор

2.3.3. Исполнитель

2.3.4. Управление контекстом

2.3.5. Синхронный вызов

2.3.6. Преимущества и недостатки

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

2.4.1. Концепция

2.4.2. Инициатор

2.4.3. Исполнитель

2.4.4. Синхронный вызов

2.4.5. Преимущества и недостатки

2.4.6. Производительность

2.5. Лямбда-выражение

2.5.1. Концепция

2.5.2. Инициатор

2.5.3. Исполнитель

2.5.4. Синхронный вызов

2.5.5. Преимущества и недостатки

2.6. Итоги

3. Сравнительный анализ реализаций

3.1. Методологические подходы

3.1.1. Обобщенный алгоритм

3.1.2. Требования как критерии

3.2. Качественный анализ

3.2.1. Матрица соответствия

3.2.2. Выбор реализации

3.3. Метод интегральных оценок

3.3.1. Количественные оценки

3.3.2. Коэффициенты важности

3.3.3. Учет прогнозных показателей

3.4. Итоги

4. Обратные вызовы и шаблоны

4.1. Общие понятия шаблонов

4.2. Синхронные вызовы

4.2.1. Инициатор

4.2.2. Преобразование вызовов

4.2.3. Исполнитель

4.3. Вызовы в алгоритмах

4.3.1. Описание проблемы

4.3.2. Параметризация типов

4.3.3. Объявление предикатов

4.3.4. Предикаты по умолчанию

4.4. Асинхронные вызовы

4.4.1. Инициатор

4.4.2. Хранение лямбда-выражений

4.4.3. Исполнитель

4.5. Универсальный аргумент

4.5.1. Динамический полиморфизм

4.5.2. Настройка сигнатуры

4.5.3. Вызов метода класса

4.6. Использование стандартной библиотеки

4.6.1. Организация вызовов

4.6.2. Инициатор с универсальным аргументом

4.6.3. Преобразование с настройкой сигнатуры

4.6.4. Исполнитель

4.6.5. Инициатор для методов класса

4.6.6. Перенаправление вызовов

4.6.7. Универсальный аргумент и производительность

4.7. Проблемы, порождаемые шаблонами

4.7.1. Недостатки шаблонов

4.7.2. Ограничения шаблонов

4.8. Итоги

5. Распределение вызовов

5.1. Постановка задачи

5.2. Статический набор получателей

5.2.1. Распределение в статическом наборе

5.2.2. Передача данных

5.3. Настройка сигнатуры для передачи данных

5.3.1. Общая концепция

5.3.2. Способ 1: объекты в пакет, данные в кортеж

5.3.3. Способ 2: объекты в кортеж, данные в пакет

5.3.4. Способ 3: объекты и данные в кортежах

5.3.5. Сравнение способов

5.3.6. Настройка сигнатуры для перенаправления

5.4. Возврат результатов выполнения

5.4.1. Получение возвращаемых значений

5.4.2. Анализ результатов

5.5. Распределитель для статического набора

5.5.1. Распределение без возврата результатов

5.5.2. Распределение с возвратом результатов

5.5.3. Параметризация возвращаемого значения

5.5.4. Вывод типов при параметризации

5.6. Динамический набор получателей

5.6.1. Распределение в динамическом наборе

5.6.2. Получение возвращаемых значений

5.7. Адресное распределение

5.7.1. Понятие адресного распределения

5.7.2. Адресный распределитель

5.7.3. Использование адресного распределения

5.8. Итоги

6. Практическое использование обратных вызовов

6.1. Разработка архитектуры

6.1.1. Техническое задание

6.1.2. Сценарий функционирования

6.1.3. Декомпозиция системы

6.2. Реализация классов

6.2.1. Общие определения

6.2.2. Обработка ошибок

6.2.3. Драйвер

6.2.4. Датчик

6.2.5. Контейнер

6.2.6. Асинхронные запросы

6.2.7. Наблюдатель

6.2.8. Интерфейсный класс

6.3. Разработка системного API

6.3.1. API как оболочка

6.3.2. Объявления типов

6.3.3. Интерфейс API и обработка ошибок

6.3.4. Многопоточная работа

6.3.5. Настройка драйвера

6.3.6. Обратные вызовы

6.4. Итоги

Заключение

Список литературы и интернет-источников

Отрывок из книги

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

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

.....

Пусть у нас будут объявления классов-исполнителей с наследованием, как показано в Листинг 12. Графически иерархия наследования изображена на Рис. 13.

Рис. 13. Иерархия наследования классов-исполнителей.

.....