Implementing the Sprout Class Technique for Adding New Functionality in C++

In this lesson, we'll focus on the sprout class technique, but this time in scenarios where we are adding new functionality and don't want to disrupt existing code. This approach is particularly useful when we want to expand capabilities while ensuring that the existing behavior remains intact.

As software evolves, new features are often added to meet changing requirements. However, integrating these features into existing classes can inadvertently affect their current functionality. This is where the sprout class technique comes into play. By creating a new class to handle additional responsibilities, we can preserve the original class's behavior. This approach not only maintains the integrity of the existing code but also makes the new functionality easier to manage and test independently.

When integrating new features into existing classes, common problems include increased complexity, reduced readability, and the risk of introducing bugs. The sprout class technique addresses these issues by isolating new behavior in a separate class. This separation of concerns ensures that the original class remains focused on its primary responsibilities, while the new class handles the additional functionality. By doing so, we maintain code clarity and reduce the likelihood of errors.

Let's explore how to implement a sprout class. We want to introduce a discount feature in the order processor based on customer loyalty without affecting the existing order processing logic. Here's how we can achieve this:

class OrderProcessor {
public:
    bool ProcessOrder(Order& order) {
        // ... order processing logic ...
        return true;
    }
};

In this example, the OrderProcessor class processes orders by calculating the total amount. To introduce a discount feature, we create a new DiscountCalculator class (we sprout it):

class DiscountCalculator {
public:
    double CalculateDiscount(const Order& order) {
        // ... discount calculation logic ...
        return 0.0;
    }
};

The DiscountCalculator class calculates a discount based on the customer's loyalty level.

Next, we introduce another sprout class, the DiscountedOrderProcessor:

class DiscountedOrderProcessor {
private:
    OrderProcessor orderProcessor;
    DiscountCalculator discountCalculator;

public:
    bool ProcessOrderWithDiscount(Order& order) {
        // ... order processing using both the existing OrderProcessor and the DiscountCalculator ...
        return true;
    }
};

Using the unchanged logic of the OrderProcessor together with the new discount logic of the DiscountCalculator, we are able to achieve the desired new behavior. While some modifications to the model classes also happen to accommodate the new behavior, we can ensure that they are backward compatible. The practice sessions following this lesson will demonstrate this.