Функциональное программирование в C++: продвинутые техники и примеры

Функциональное программирование в C++: продвинутый уровень

Функциональное программирование (ФП) — это парадигма, рассматривающая вычисления как вычисление математических функций и избегающая изменяемого состояния и побочных эффектов. Хотя C++ традиционно ассоциируется с объектно-ориентированным и процедурным программированием, современные стандарты (C++11 и новее) внедрили мощные инструменты для написания функционального кода. В этой статье мы выйдем за рамки базовых лямбд и рассмотрим продвинутые техники: от композиции функций до эмуляции монад.

1. Композиция функций и конвейеры

Композиция функций — это процесс объединения двух или более функций для создания новой функции. В C++ для этого удобно использовать лямбда-выражения и шаблоны.

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>

// Шаблон для композиции двух функций
template<typename F, typename G>
auto compose(F f, G g) {
    return [f, g](auto x) {
        return f(g(x));
    };
}

// Пример использования
int main() {
    auto addTwo = [](int x) { return x + 2; };
    auto multiplyByThree = [](int x) { return x * 3; };

    // Композиция: сначала multiplyByThree, потом addTwo
    auto composed = compose(addTwo, multiplyByThree);

    std::cout << composed(5) << std::endl; // (5*3) + 2 = 17

    // Конвейерная обработка (pipe) с помощью std::ranges (C++20)
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    auto result = numbers
        | std::views::filter([](int n) { return n % 2 == 0; })
        | std::views::transform([](int n) { return n * n; });

    for (int n : result) {
        std::cout << n << " "; // 4 16
    }
    return 0;
}

Конвейеры с std::views (C++20) позволяют строить цепочки преобразований без создания промежуточных контейнеров, что является классическим функциональным подходом.

2. Каррирование (Currying) и частичное применение

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

#include <iostream>
#include <functional>

// Каррированная функция сложения
auto curriedAdd = [](int a) {
    return [a](int b) {
        return [a, b](int c) {
            return a + b + c;
        };
    };
};

// Частичное применение с помощью std::bind
int multiply(int a, int b, int c) {
    return a * b * c;
}

int main() {
    // Использование каррирования
    auto add5 = curriedAdd(5);
    auto add5And3 = add5(3);
    std::cout << add5And3(2) << std::endl; // 10

    // Частичное применение через std::bind
    using namespace std::placeholders;
    auto multiplyBy2 = std::bind(multiply, _1, _2, 2);
    std::cout << multiplyBy2(3, 4) << std::endl; // 3*4*2 = 24

    // Частичное применение через лямбду (более идиоматично в C++14+)
    auto multiplyBy3 = [](int a, int b) { return multiply(a, b, 3); };
    std::cout << multiplyBy3(5, 6) << std::endl; // 5*6*3 = 90

    return 0;
}

Каррирование особенно полезно при работе с функциями высшего порядка, такими как std::transform или std::accumulate, позволяя создавать специализированные версии функций "на лету".

3. Функторы, аппликативы и эмуляция монад

В Haskell монады — это мощный паттерн для работы с побочными эффектами. В C++ мы можем эмулировать их с помощью шаблонов классов. Рассмотрим простую монаду Maybe (аналог std::optional), но с монадическими операциями.

#include <iostream>
#include <functional>
#include <optional>

// Монада Maybe (обертка над std::optional)
template<typename T>
class Maybe {
    std::optional<T> value;
public:
    Maybe() : value(std::nullopt) {}
    Maybe(T v) : value(v) {}

    // fmap (функтор) — применяет функцию к значению, если оно есть
    template<typename F>
    auto fmap(F f) const -> Maybe<decltype(f(*value))> {
        if (value) {
            return Maybe<decltype(f(*value))>(f(*value));
        }
        return Maybe<decltype(f(*value))>();
    }

    // bind (монадический оператор >>=)
    template<typename F>
    auto bind(F f) const -> decltype(f(*value)) {
        if (value) {
            return f(*value);
        }
        return decltype(f(*value))();
    }

    // Вывод значения (для демонстрации)
    void print() const {
        if (value) std::cout << *value << std::endl;
        else std::cout << "Nothing" << std::endl;
    }
};

// Функция, возвращающая Maybe
Maybe<int> safeDivide(int a, int b) {
    if (b == 0) return Maybe<int>();
    return Maybe<int>(a / b);
}

int main() {
    Maybe<int> m1(10);
    Maybe<int> m2(0);

    // Цепочка монадических операций
    auto result1 = m1.bind([&](int x) {
        return safeDivide(x, 2).bind([&](int y) {
            return Maybe<int>(y + 3);
        });
    });
    result1.print(); // 8 (10/2 + 3)

    auto result2 = m2.bind([&](int x) {
        return safeDivide(x, 2).bind([&](int y) {
            return Maybe<int>(y + 3);
        });
    });
    result2.print(); // Nothing (деление на ноль)

    return 0;
}

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

Блоги

Clean Code на C++: принципы и примеры на практике

Dependency Injection в Rust: для начинающих

10 лучших фреймворков Rust для веб-разработки: продвинутый уровень

Рекомендаций по книгам

Рефакторинг TypeScript кода: улучшение проектов с помощью проверенных методов

API разработка на C++: Создание производительных веб-сервисов

Освоение модульного JavaScript

Продвинутая отладка и реверс-инжиниринг Apple

Читайте также

Работа с WebAssembly и Rust: продвинутый уровень оптимизации и интеграции C# разработчик: зарплаты, перспективы и будущее рынка в 2025 Docker и PHP: контейнеризация приложений продвинутого уровня Ревью кода на Java: что ищут senior-ы и как не провалить код-ревью Регулярные выражения в C#: полное руководство с примерами