Какие знаешь парадигмы программирования кроме ООП?

Парадигмы программирования в C++

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

1. Императивное (процедурное) программирование

Суть: описание последовательности команд, которые изменяют состояние программы.

// Классический процедурный стиль
void sortArray(int* arr, int size) {
    // Явное описание всех шагов сортировки
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Явная команда: поменять элементы
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// Главная программа
int main() {
    int data[] = {5, 2, 8, 1, 9};
    sortArray(data, 5);
    return 0;
}

Преимущества:

• Полный контроль над потоком выполнения
• Предсказуемость и простота анализа
• Низкие накладные расходы

Когда использовать: системное программирование, критичные по производительности секции, встроенные системы.

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

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

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // Функциональный подход: трансформация данных
    std::vector<int> doubled;
    std::transform(numbers.begin(), numbers.end(),
                   std::back_inserter(doubled),
                   [](int x) { return x * 2; });  // Чистая функция
    
    // Filter: оставить только чётные
    std::vector<int> evens;
    std::copy_if(numbers.begin(), numbers.end(),
                 std::back_inserter(evens),
                 [](int x) { return x % 2 == 0; });
    
    // Reduce: сумма всех элементов
    int sum = 0;
    std::for_each(numbers.begin(), numbers.end(),
                  [&sum](int x) { sum += x; });
    
    return 0;
}

Ключевые концепции:

• Чистые функции — одинаковый вход дает одинаковый выход
• Неизменяемость — данные не меняются, создаются новые копии
• Higher-order функции — функции принимают функции как параметры

Преимущества:

• Легче тестировать и рассуждать о коде
• Параллелизм безопаснее (нет побочных эффектов)
• Меньше багов, связанных с состоянием

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

3. Декларативное программирование

Суть: описание ЧТО нужно достичь, а не КАК это делать.

// SQL — классический пример декларативного подхода
// SELECT * FROM users WHERE age > 18 AND city = Moscow;

// В C++ с использованием range-based libraries (диапазоны в C++20)
#include <ranges>
#include <vector>

struct User {
    std::string name;
    int age;
    std::string city;
};

int main() {
    std::vector<User> users = {
        {"Alice", 25, "Moscow"},
        {"Bob", 17, "SPB"},
        {"Charlie", 30, "Moscow"},
    };
    
    // C++20 ranges — декларативный стиль
    auto results = users
        | std::views::filter([](const User& u) { return u.age > 18; })
        | std::views::filter([](const User& u) { return u.city == "Moscow"; });
    
    for (const auto& user : results) {
        // Обработка результатов
    }
    
    return 0;
}

Когда использовать: запросы к БД, конфигурационные файлы, высокоуровневые описания логики.

4. Логическое программирование

Суть: описание фактов и правил, система автоматически находит решение.

// C++ не имеет встроенной поддержки, но концепция применяется
// Пример: поиск в графе через правила

bool isConnected(const Graph& graph, int start, int end) {
    // Факты: прямые соединения
    // Правила: транзитивность соединений
    // Система выводит: достижимость вершины
    
    std::vector<bool> visited(graph.vertexCount(), false);
    std::queue<int> q;
    q.push(start);
    visited[start] = true;
    
    while (!q.empty()) {
        int current = q.front();
        q.pop();
        
        if (current == end) return true;
        
        for (int neighbor : graph.getNeighbors(current)) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
    return false;
}

5. Событийно-ориентированное программирование

Суть: программа реагирует на события, которые могут происходить асинхронно.

class EventSystem {
private:
    using EventHandler = std::function<void(const Event&)>;
    std::map<std::string, std::vector<EventHandler>> handlers;
    
public:
    void subscribe(const std::string& eventType, EventHandler handler) {
        handlers[eventType].push_back(handler);
    }
    
    void emit(const std::string& eventType, const Event& event) {
        for (auto& handler : handlers[eventType]) {
            handler(event);
        }
    }
};

// Использование
EventSystem events;
events.subscribe("user_logged_in", [](const Event& e) {
    std::cout << "User logged in: " << e.data << std::endl;
});

events.emit("user_logged_in", Event{"alice"});

Когда использовать: GUI приложения, асинхронные серверы, реактивные системы.

6. Обобщённое программирование (Generic Programming)

Суть: написание кода, работающего с различными типами через шаблоны.

// Generic алгоритм, работающий с любым контейнером
template<typename Container, typename T>
int countOccurrences(const Container& cont, const T& value) {
    return std::count(cont.begin(), cont.end(), value);
}

// Работает с vector, list, deque и т.д.
std::vector<int> v = {1, 2, 2, 3, 2};
std::list<std::string> l = {"a", "b", "a"};

int intCount = countOccurrences(v, 2);          // 3
int strCount = countOccurrences(l, "a");        // 2

STL (Standard Template Library) — практическое воплощение обобщённого программирования.

Сравнение парадигм

Best Practices для многопарадигмального подхода

1. Выбирайте подходящую парадигму для конкретной задачи
2. Комбинируйте подходы — например, ООП + функциональное + обобщённое
3. Не смешивайте без причины — чёткость важнее полноты
4. Изучайте STL — это энциклопедия хороших практик многопарадигмального кода
5. Документируйте намерения — почему выбрана каждая парадигма

Опытный C++ разработчик владеет всеми парадигмами и гибко переключается между ними в зависимости от контекста.