Что такое процедурное программирование?

Процедурное программирование: парадигма и практика

Процедурное программирование (Imperative/Procedural Programming) — это парадигма программирования, где код состоит из последовательности процедур (функций), которые изменяют состояние программы пошагово. Это один из старейших и наиболее широко используемых подходов к разработке ПО.

Основные принципы

1. Последовательность команд

Код выполняется пошагово, одна команда за другой:

// Процедурный подход — явная последовательность действий
int main() {
    int a = 10;                    // Шаг 1: создать переменную
    int b = 20;                    // Шаг 2: создать переменную
    int sum = a + b;               // Шаг 3: вычислить сумму
    printf("Sum: %d\n", sum);     // Шаг 4: вывести результат
    return 0;                       // Шаг 5: выход
}

2. Изменение состояния (State)

Программа имеет состояние, которое изменяется во время выполнения:

int counter = 0;                   // Состояние

int increment() {
    counter++;                     // Изменяем состояние
    return counter;
}

int main() {
    printf("%d\n", increment());  // Выводит 1
    printf("%d\n", increment());  // Выводит 2
    printf("%d\n", increment());  // Выводит 3
    return 0;
}

3. Процедуры и функции

Логика организована в функции (процедуры):

void processUser(int userId) {
    User user = database.getUser(userId);      // Получить
    user.updateLastLogin();                    // Изменить
    user.incrementLoginCount();                // Изменить
    database.saveUser(user);                   // Сохранить
    notifyUser(user);                          // Уведомить
}

void handleRequest(int userId) {
    processUser(userId);                       // Вызов процедуры
    logActivity(userId, "logged_in");          // Вызов процедуры
}

Характерные особенности

1. Императивный стиль (указание КАК)

// ❌ Функциональный подход (указание ЧТО нужно)
std::vector<int> evens = numbers
    | std::views::filter([](int x) { return x % 2 == 0; });

// ✅ Процедурный подход (указание КАК это делать)
std::vector<int> evens;
for (int num : numbers) {
    if (num % 2 == 0) {
        evens.push_back(num);
    }
}

2. Явные циклы и условия

// Процедурный код — видны все шаги
int sumArray(int* arr, int size) {
    int sum = 0;                   // Инициализация
    for (int i = 0; i < size; i++) { // Цикл
        sum += arr[i];             // Изменение состояния
    }
    return sum;                    // Возврат результата
}

3. Глобальное и локальное состояние

// Глобальное состояние
int globalCounter = 0;

void processUser(User& user) {
    user.id++;                     // Изменение локального состояния
    globalCounter++;               // Изменение глобального состояния
    user.lastProcessed = time(NULL); // Изменение времени
}

Реальные примеры

1. Обработка заказа в e-commerce

void processOrder(int orderId) {
    // Шаг 1: загрузить заказ
    Order order = db.getOrder(orderId);
    
    // Шаг 2: проверить наличие товара
    for (const OrderItem& item : order.items) {
        int stock = db.getStock(item.productId);
        if (stock < item.quantity) {
            order.status = "failed";
            db.saveOrder(order);
            return;
        }
    }
    
    // Шаг 3: списать со склада
    for (const OrderItem& item : order.items) {
        db.decreaseStock(item.productId, item.quantity);
    }
    
    // Шаг 4: обработать платёж
    bool paymentOk = payment.charge(order.total, order.cardToken);
    if (!paymentOk) {
        // Отменить списание
        for (const OrderItem& item : order.items) {
            db.increaseStock(item.productId, item.quantity);
        }
        order.status = "payment_failed";
        db.saveOrder(order);
        return;
    }
    
    // Шаг 5: создать отгрузку
    Shipment shipment;
    shipment.orderId = orderId;
    shipment.status = "pending";
    db.saveShipment(shipment);
    
    // Шаг 6: отправить уведомление
    email.send(order.customerEmail, "Order confirmed");
    
    // Шаг 7: сохранить результат
    order.status = "confirmed";
    order.processedAt = time(NULL);
    db.saveOrder(order);
}

2. Обработка сетевого запроса

void handleNetworkRequest(SOCKET client, const std::string& request) {
    // Шаг 1: парсить запрос
    HttpRequest httpReq;
    if (!parseRequest(request, httpReq)) {
        sendError(client, 400, "Bad Request");
        return;
    }
    
    // Шаг 2: проверить аутентификацию
    std::string token = httpReq.getHeader("Authorization");
    User user = db.getUserByToken(token);
    if (!user.isValid()) {
        sendError(client, 401, "Unauthorized");
        return;
    }
    
    // Шаг 3: обработать запрос в зависимости от метода
    std::string response;
    if (httpReq.method == "GET") {
        response = handleGet(httpReq, user);
    } else if (httpReq.method == "POST") {
        response = handlePost(httpReq, user);
    } else {
        response = handleError(405, "Method Not Allowed");
    }
    
    // Шаг 4: отправить ответ
    send(client, response.c_str(), response.size(), 0);
}

Процедурное программирование vs ООП

Преимущества процедурного подхода

1. Простота и прямолинейность

// Сразу видно, что происходит
int result = calculateSum(arr);
printf("%d\n", result);

2. Легче отладка

• Можно пошагово пройти по коду
• Видно все изменения состояния
• Меньше скрытых побочных эффектов

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

• Минимальные накладные расходы
• Легче оптимизировать
• Идеально для системного программирования

4. Лёгкость понимания

• Новички быстро учатся
• Меньше абстракций
• Код читается как инструкция

Недостатки

1. Сложность масштабирования

// В больших проектах код становится запутанным
globalCounter++;           // Где ещё используется?
static int maxValue = 100; // Видимо только здесь?
int temp = calculate();    // Зачем этот временный результат?

2. Дублирование кода

// Логика может повторяться в разных местах
void processUser1() {
    user.update();
    cache.clear();
    log.write("processed");
}

void processUser2() {
    user.update();  // Повторение
    cache.clear();  // Повторение
    log.write("processed");  // Повторение
}

3. Побочные эффекты

// Функция может неявно менять состояние
int getValue() {
    counter++;          // Побочный эффект!
    return value;
}

Когда использовать процедурный подход?

Хорош для:

• Системного программирования (драйверы, ОС)
• Встроенных систем (микроконтроллеры)
• Высоконагруженных систем (где каждый наносекунда считается)
• Скриптов и утилит
• Алгоритмических задач (структуры данных, обработка)

Плохой для:

• Больших проектов (10k+ строк)
• Командной разработки
• Сложного бизнес-логики
• Долгосрочного поддержания

Современный C++ и процедурное программирование

Модерный C++ комбинирует подходы:

// Процедурное ядро...
void processData(std::vector<Data>& data) {
    for (auto& item : data) {        // Явный цикл
        item.validate();             // Процедура
        if (item.isValid()) {        // Условие
            item.transform();        // Процедура
        }
    }
}

// ...но с ООП оберткой
class DataProcessor {
public:
    void process(std::vector<Data>& data) {
        processData(data);
    }
private:
    // Деталь реализации
};

Итог

Процедурное программирование — это фундаментальная парадигма, особенно важная для backend разработчика на C/C++. Даже если вы используете ООП, понимание процедурного стиля критично для:

• Написания производительного кода
• Отладки и понимания поведения
• Работы с системным кодом
• Оптимизации критичных участков

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