Clean Code in C++: Principles and Practical Examples

Introduction: Why Clean Code Matters for C++

C++ is a powerful and flexible language that allows you to write both highly efficient system code and complex application solutions. However, this flexibility often leads to chaos: overloaded functions, implicit conversions, manual memory management, and macros can turn a project into a "swamp" within months. The concept of Clean Code, popularized by Robert Martin, is fully applicable to C++, but with consideration for the language's specifics.

In this article, we will break down the key principles of clean code in C++ and demonstrate their application with real-world examples. You will learn how to write code that is easy to read, test, and maintain.

1. Naming and Structure: The Foundation of Readability

1.1. Meaningful Variable and Function Names

The first rule of clean code is that a name should reveal intent. In C++, this is especially important due to the presence of overloading and templates.

Bad example:

int d; // elapsed time in days\nvoid proc(int a, int b); // what are a and b?

Good example:

int elapsedTimeInDays;\nvoid processData(const std::vector<int>& inputData, int maxIterations);

1.2. Classes and Namespaces

Use namespaces for logical grouping. Avoid global variables — this is an anti-pattern.

namespace network {\n    class TcpConnection {\n    public:\n        void connect(const std::string& host, int port);\n        void send(const std::vector<char>& data);\n    private:\n        int socket_;\n    };\n} // namespace network

2. Functions: Small and with a Single Responsibility

2.1. Single Responsibility Principle (SRP)

A function should do only one thing. If a function does more than one action — break it up.

Bad example:

void processOrder(Order& order) {\n    // validation\n    if (order.total < 0) throw std::invalid_argument("Negative total");\n    // save to database\n    database.save(order);\n    // send email\n    emailService.send(order.customerEmail, "Order confirmed");\n}

Good example:

bool validateOrder(const Order& order);\nvoid saveOrderToDatabase(const Order& order);\nvoid sendConfirmationEmail(const Order& order);\n\nvoid processOrder(Order& order) {\n    if (!validateOrder(order)) return;\n    saveOrderToDatabase(order);\n    sendConfirmationEmail(order);\n}

2.2. Avoid Side Effects

A function should not change global state without explicit need. Use const references and return values instead of modifying arguments.

// Bad: modifies the input vector\nvoid addPrefix(std::vector<std::string>& words, const std::string& prefix) {\n    for (auto& word : words) {\n        word = prefix + word;\n    }\n}\n\n// Good: returns a new vector\nstd::vector<std::string> addPrefix(const std::vector<std::string>& words, const std::string& prefix) {\n    std::vector<std::string> result;\n    result.reserve(words.size());\n    for (const auto& word : words) {\n        result.push_back(prefix + word);\n    }\n    return result;\n}

3. Memory Management and RAII

3.1. Use Smart Pointers

In modern C++ (C++11 and later), manual memory management via new/delete is considered outdated. Use std::unique_ptr and std::shared_ptr.

// Bad: memory leak possible\nvoid process() {\n    Resource* res = new Resource();\n    // ... if an exception occurs here, memory leaks\n    delete res;\n}\n\n// Good: automatic deallocation\nvoid process() {\n    a