Что использовал на своем проекте?

Использованные технологии в моём проекте

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

Архитектура и проектирование

Многоуровневая архитектура

Большинство моих проектов строились на основе многоуровневой архитектуры:

// Infrastructure layer — работа с ресурсами
class DatabaseConnection {
    std::unique_ptr<SQLConnection> connection_;
public:
    Result executeQuery(const std::string& query);
};

// Application layer — бизнес-логика
class UserService {
    std::shared_ptr<DatabaseConnection> db_;
public:
    void createUser(const std::string& name);
};

// Presentation layer — API
class RestHandler {
    std::unique_ptr<UserService> service_;
public:
    void handleCreateUserRequest(const Request& req);
};

Этот подход позволял:

• Легко тестировать компоненты независимо
• Менять реализацию деталей без влияния на верхние слои
• Управлять зависимостями явно

SOLID принципы

Всегда следил за применением SOLID:

// Single Responsibility
class Logger {
    void log(const std::string& message);
};

class DataProcessor {
    std::shared_ptr<Logger> logger_;
    void process(const Data& data);
};

// Open/Closed Principle
class StorageBase {
public:
    virtual ~StorageBase() = default;
    virtual void save(const Data& data) = 0;
    virtual Data load(const ID& id) = 0;
};

class FileStorage : public StorageBase { /* ... */ };
class DatabaseStorage : public StorageBase { /* ... */ };

// Dependency Inversion
class Repository {
    std::unique_ptr<StorageBase> storage_;  // Зависим от interface
public:
    Repository(std::unique_ptr<StorageBase> storage) 
        : storage_(std::move(storage)) {}
};

Управление памятью

Умные указатели

Всегда использовал современные smart pointers:

// unique_ptr для exclusive ownership
std::unique_ptr<DataProcessor> processor(new DataProcessor());

// shared_ptr для shared ownership
std::vector<std::shared_ptr<EventListener>> listeners;

// RAII для ресурсов
class ResourceGuard {
    FILE* file_;
public:
    ResourceGuard(const std::string& path) 
        : file_(fopen(path.c_str(), "r")) {}
    
    ~ResourceGuard() { 
        if (file_) fclose(file_); 
    }
    
    // Delete copy, allow move
    ResourceGuard(const ResourceGuard&) = delete;
    ResourceGuard& operator=(const ResourceGuard&) = delete;
    
    ResourceGuard(ResourceGuard&& other) noexcept 
        : file_(other.file_) { 
        other.file_ = nullptr; 
    }
};

Параллелизм

Многопоточность

Для высоконагруженных сервисов использовал:

#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

class ThreadPool {
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    std::mutex queue_mutex_;
    std::condition_variable cv_;
    bool stop_ = false;
    
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers_.emplace_back([this] { workerThread(); });
        }
    }
    
    void submit(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex_);
            tasks_.push(std::move(task));
        }
        cv_.notify_one();
    }
    
private:
    void workerThread() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(queue_mutex_);
                cv_.wait(lock, [this] { return !tasks_.empty() || stop_; });
                if (stop_ && tasks_.empty()) break;
                task = std::move(tasks_.front());
                tasks_.pop();
            }
            task();
        }
    }
};

Синхронизация

Для сложных сценариев использовал:

// Атомарные операции
std::atomic<int> counter(0);
counter++;  // Thread-safe

// Read-Write lock для частых чтений
std::shared_mutex data_mutex_;
std::vector<Data> data_;

// Reader
{
    std::shared_lock<std::shared_mutex> lock(data_mutex_);
    for (const auto& d : data_) { /* process */ }
}

// Writer
{
    std::unique_lock<std::shared_mutex> lock(data_mutex_);
    data_.push_back(new_data);
}

Работа с памятью

Кэширование и пулы объектов

template<typename T>
class ObjectPool {
    std::vector<std::unique_ptr<T>> available_;
    std::vector<std::unique_ptr<T>> in_use_;
    std::mutex pool_mutex_;
    
public:
    std::shared_ptr<T> acquire() {
        std::lock_guard<std::mutex> lock(pool_mutex_);
        if (!available_.empty()) {
            auto obj = std::move(available_.back());
            available_.pop_back();
            return std::shared_ptr<T>(obj.release(), 
                [this](T* ptr) { release(ptr); });
        }
        return std::make_shared<T>();
    }
    
private:
    void release(T* ptr) {
        std::lock_guard<std::mutex> lock(pool_mutex_);
        available_.push_back(std::unique_ptr<T>(ptr));
    }
};

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

Exception-safe код

class Transaction {
    Database& db_;
    bool committed_ = false;
    
public:
    ~Transaction() {
        if (!committed_) {
            db_.rollback();  // RAII гарантирует откат
        }
    }
    
    void execute(const std::string& query) {
        if (!db_.execute(query)) {
            throw DatabaseException("Query failed");
        }
    }
    
    void commit() {
        db_.commit();
        committed_ = true;
    }
};

// Использование
try {
    Transaction txn(db);
    txn.execute("INSERT ...");
    txn.execute("UPDATE ...");
    txn.commit();
} catch (const DatabaseException& e) {
    // Откат произойдёт автоматически
    std::cerr << "Error: " << e.what();
}

Оптимизация производительности

Профилирование

class PerformanceTimer {
    std::chrono::high_resolution_clock::time_point start_;
    std::string name_;
    
public:
    PerformanceTimer(const std::string& name) 
        : name_(name), 
          start_(std::chrono::high_resolution_clock::now()) {}
    
    ~PerformanceTimer() {
        auto duration = std::chrono::high_resolution_clock::now() - start_;
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
        std::cout << name_ << ": " << ms.count() << " ms\n";
    }
};

// Использование
{
    PerformanceTimer timer("Database query");
    // Выполняем дорогую операцию
    auto results = db.query(sql);
}  // Выводит время выполнения

Кэширование результатов

template<typename Key, typename Value>
class Cache {
    std::unordered_map<Key, Value> data_;
    std::shared_mutex cache_mutex_;
    
public:
    std::optional<Value> get(const Key& key) {
        std::shared_lock<std::shared_mutex> lock(cache_mutex_);
        auto it = data_.find(key);
        if (it != data_.end()) return it->second;
        return std::nullopt;
    }
    
    void put(const Key& key, const Value& value) {
        std::unique_lock<std::shared_mutex> lock(cache_mutex_);
        data_[key] = value;
    }
};

Тестирование

Unit-тесты с Google Test

#include <gtest/gtest.h>

class UserServiceTest : public ::testing::Test {
public:
    MockDatabase mock_db;
    UserService service{&mock_db};
};

TEST_F(UserServiceTest, CreateUserSuccess) {
    EXPECT_CALL(mock_db, insert(::testing::_))
        .WillOnce(::testing::Return(true));
    
    ASSERT_TRUE(service.createUser("John"));
}

Модерные стандарты

• C++11: move semantics, nullptr, auto
• C++14: auto return types, lambda captures
• C++17: structured bindings, optional, variant
• C++20: concepts (начинал использовать)

Ключевые learnings

1. Memory safety — критична для production кода
2. RAII — главный паттерн C++ для управления ресурсами
3. Move semantics — улучшает производительность на порядки
4. Exception safety — требует осторожности и тестирования
5. Многопоточность — требует discipline и правильной синхронизации
6. Профилирование — не гадай, измеряй!

Эти подходы позволили мне создавать масштабируемые, надёжные и быстрые системы на C++.