Что такое функциональное программирование (ФП) и как его принципы применяются в C++?

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

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

// Вот это — святость. Дали число, получили квадрат. Всё.
int square(int x) { return x * x; }

// А вот это — уже маньяк. Он и глобальную переменную испортит, и тебе соврёт.
int global = 0;
int impure(int x) { global += x; return x * 2; }

Использовать таких маньяков — это как держать дома бензопилу без чехла: рано или поздно отпилишь себе что-нибудь важное. Особенно в многопоточке, там вообще будет хиросима и нигерсраки.

Дальше — функции как объекты первого класса. Это когда с функцией можно делать всё то же, что и с обычной переменной: пихать её в аргументы, возвращать из другой функции, складывать в контейнер. В C++ для этого есть std::function и лямбды. Выглядит иногда страшновато, но, ёпта, мощно.

// Функция, которая принимает другую функцию как аргумент — это уже функция высшего порядка.
// Звучит умно, а на деле — просто инструмент.
void apply_to_all(std::vector<int>& vec, std::function<int(int)> func) {
    for (int& elem : vec) {
        elem = func(elem); // Применяем переданную операцию к каждому элементу
    }
}

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

Следующий столп — иммутабельность, то есть неизменяемость. В мире ФП данные, однажды созданные, должны быть как высеченные в камне. В C++ за этим следит мой любимый const. Поставил — и спи спокойно, никто твой массив не испортит.

const std::vector<int> immutable_data = {1, 2, 3};
// immutable_data.push_back(4); // Попробуй только — компилятор тебе мозги выест.

А если нужно преобразовать данные, то ты не ковыряешь старые, а создаёшь новые. Алгоритмы вроде std::transform — твои лучшие друзья. Да, памяти жрёт больше, но зато доверия к такому коду — ебать ноль, в хорошем смысле. Никто не подкрадётся сбоку и не изменит твои данные пока ты не видишь.

И, конечно, рекурсия. В истинно функциональных языках это основной способ организовать цикл. В C++ с этим... сложнее. Компилятор не обязан делать оптимизацию хвостовой рекурсии (TCO), так что если переборщишь — получишь красивый stack overflow и программу, которая накрылась медным тазом. Но для некоторых задач (обход деревьев, например) — штука незаменимая.

Так в чём же, блядь, польза от всей этой возни в C++? А польза — в надёжности. Код, написанный с оглядкой на ФП-принципы (чистые функции, const везде, где можно), — это код, который в десять раз проще тестировать. В нём нет скрытых зависимостей, за ним не нужно бегать с дебаггером, гадая, кто и когда испортил глобальное состояние. Его легче распараллелить, потому что нет борьбы за общие ресурсы. Это как перейти от бардака в общей комнате к строгому порядку в личном кабинете. Да, сначала непривычно, зато потом терпения ноль ебать тратить на поиск багов, которых просто не возникает.