Refactoring Overloaded Methods in C++ Using the Sprout Method

Introduction

Now that we have had a warm-up with the sprout method technique, let's explore another use case for it. We'll focus on another crucial aspect of refactoring: identifying and addressing methods that do too much. This lesson will guide us through the process of recognizing overloaded methods and using the sprout method to refactor them, ensuring our code remains clean, efficient, and maintainable.

Identifying Overloaded Methods

Methods that handle multiple responsibilities can be challenging to manage and understand. These overloaded methods often violate the single responsibility principle, which states that a method should have only one reason to change. Recognizing such methods is the first step in refactoring. We should look for methods that perform several distinct tasks or have multiple logical sections. These are indicators that a method might be doing too much and could benefit from refactoring. Overloaded methods can lead to several problems. They reduce code readability, making it difficult for developers to understand the method's purpose at a glance. This complexity can also increase the likelihood of bugs, as changes to one part of the method might inadvertently affect another.

Refactoring with the Sprout Method

The sprout method offers a structured approach to refactoring overloaded methods. By extracting portions of a method into new, focused methods, we can adhere to the single responsibility principle. Here's a step-by-step guide: Identify Distinct Responsibilities : We examine the method to identify different tasks it performs. Create New Methods : For each distinct responsibility, we create a new method that encapsulates that functionality. Refactor the Original Method : We replace the extracted logic in the original method with calls to the new methods, ensuring it remains focused and concise. In the previous lesson, we used the sprout method to introduce new functionality without affecting existing logic, ensuring stability while expanding capabilities. In contrast, when applied to overloaded methods, the sprout method focuses on refactoring by breaking down a method with multiple responsibilities into smaller, focused methods. While both uses aim to improve code quality, the former emphasizes stability during expansion, and the latter focuses on reducing complexity and enhancing clarity.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Real-World Example

Let's examine another permutation of the order processing logic, this time overloaded with logic. The following example uses modern C++ best practices, including smart pointers for dependency management and references for object access:

C++

class OrderProcessor {
    std::shared_ptr<DatabaseConnection> _dbConnection;
    std::shared_ptr<PaymentGateway> _paymentGateway;
    std::shared_ptr<EmailService> _emailService;

public:
    OrderProcessor(
        std::shared_ptr<DatabaseConnection> dbConnection,
        std::shared_ptr<PaymentGateway> paymentGateway,
        std::shared_ptr<EmailService> emailService)
        : _dbConnection(std::move(dbConnection)),
          _paymentGateway(std::move(paymentGateway)),
          _emailService(std::move(emailService)) {}

    bool ProcessOrder(Order& order) {
        try {
            // Part 1: Fetch customer data
            auto customer = _dbConnection->GetCustomerById(order.CustomerId);
            if (!customer) return false;

            // Part 2: Calculate order total with discounts
            double totalAmount = 0;
            for (const auto& item : order.Items) {
                auto product = _dbConnection->GetProductById(item.ProductId);
                if (!product) continue;

                double itemPrice = product->Price * item.Quantity;
                if (customer->IsPremium) {
                    itemPrice *= 0.9;
                }
                totalAmount += itemPrice;
            }

            // Part 3: Process payment
            PaymentGateway::PaymentResult paymentResult = _paymentGateway->ProcessPayment(totalAmount);
            if (!paymentResult.Success) return false;

            // Part 4: Update order status in database
            UpdateStatus(order);

            // Part 5: Send confirmation email
            _emailService->SendOrderConfirmation(customer->Email, order.Id, totalAmount);

            return true;
        } catch (const std::exception& ex) {
            // Part 6: Error handling
            std::cerr << "Error processing order: " << ex.what() << std::endl;
            return false;
        }
    }

private:
    void UpdateStatus(Order& order) {
        _dbConnection->UpdateOrderStatus(order.Id, "Paid");
        order.ProcessedAt = std::time(nullptr);
    }
};

class OrderProcessor {
    std::shared_ptr<DatabaseConnection> _dbConnection;
    std::shared_ptr<PaymentGateway> _paymentGateway;
    std::shared_ptr<EmailService> _emailService;

public:
    OrderProcessor(
        std::shared_ptr<DatabaseConnection> dbConnection,
        std::shared_ptr<PaymentGateway> paymentGateway,
        std::shared_ptr<EmailService> emailService)
        : _dbConnection(std::move(dbConnection)),
          _paymentGateway(std::move(paymentGateway)),
          _emailService(std::move(emailService)) {}

    bool ProcessOrder(Order& order) {
        try {
            // Part 1: Fetch customer data
            auto customer = _dbConnection->GetCustomerById(order.CustomerId);
            if (!customer) return false;

            // Part 2: Calculate order total with discounts
            double totalAmount = 0;
            for (const auto& item : order.Items) {
                auto product = _dbConnection->GetProductById(item.ProductId);
                if (!product) continue;

                double itemPrice = product->Price * item.Quantity;
                if (customer->IsPremium) {
                    itemPrice *= 0.9;
                }
                totalAmount += itemPrice;
            }

            // Part 3: Process payment
            PaymentGateway::PaymentResult paymentResult = _paymentGateway->ProcessPayment(totalAmount);
            if (!paymentResult.Success) return false;

            // Part 4: Update order status in database
            UpdateStatus(order);

            // Part 5: Send confirmation email
            _emailService->SendOrderConfirmation(customer->Email, order.Id, totalAmount);

            return true;
        } catch (const std::exception& ex) {
            // Part 6: Error handling
            std::cerr << "Error processing order: " << ex.what() << std::endl;
            return false;
        }
    }

private:
    void UpdateStatus(Order& order) {
        _dbConnection->UpdateOrderStatus(order.Id, "Paid");
        order.ProcessedAt = std::time(nullptr);
    }
};

In this example, dependencies are managed using std::shared_ptr, and objects such as Order are passed by reference. The method handles multiple tasks: fetching customer data, calculating the order total, processing payment, updating order status, and sending a confirmation email. By applying the sprout method, we can refactor this into smaller methods, each handling a specific responsibility.

For example, we have extracted the logic for updating order status to a separate method:

C++

void UpdateStatus(Order& order) {
    _dbConnection->UpdateOrderStatus(order.Id, "Paid");
    order.ProcessedAt = std::time(nullptr);
}

void UpdateStatus(Order& order) {
    _dbConnection->UpdateOrderStatus(order.Id, "Paid");
    order.ProcessedAt = std::time(nullptr);
}

We then call this method in place of the logic that it contains within the ProcessOrder method. This not only makes the code more readable but also easier to test and maintain. We will focus on doing just that in the upcoming practice sessions.

Introduction

Identifying Overloaded Methods

Refactoring with the Sprout Method

Join the 1M+ learners on CodeSignal

Benefits of the Sprout Method

Real-World Example

Summary and Preparation for Practice Exercises