Refactoring Techniques in C++ | CodeSignal Learn

Refactoring Techniques in C++ | CodeSignal Learn

Introduction to the Course Path

Welcome to the course path for Refactoring Techniques in C++ . Before we begin the first course, let's discuss the themes of this course path, what we will cover, and how we will approach our practice sessions. Our journey will focus on equipping us with the skills to confidently modify existing codebases while minimizing the risk of introducing bugs. By the end of this course, we'll be well-versed in various strategies to make our code more testable and reliable.

Challenges in Established Codebases

Working with established codebases often presents unique challenges. These include dealing with tightly coupled components, a lack of documentation, and the fear of breaking existing functionality when making changes. Without the use of proper tools and techniques, even minor modifications can lead to unexpected issues.

Tools Used Within This Course Path

As we progress through the path, we will be using a few C++ libraries to help us along the way. While they are going to be used extensively within this course, keep in mind that they are just some of the options available out there and that other projects might use different tools. The point is to understand why we use them, not the particular tool. We'll be using Google Test, a popular testing framework, to write and run tests effectively. Refactoring will be a significant focus, as it helps increase testability by creating abstract classes and breaking down dependencies. We'll also explore the use of Google Mock, a mocking library, to isolate and test components without external dependencies.

Topics Covered Within This Course Path

All courses will work with an existing codebase. This means that we will always start with some existing state and will use it to demonstrate a concept, technique, or strategy. The first course will revolve around writing tests and enhancing testability. The second course will go deeper into breaking dependencies and how to use techniques like abstract classes and dependency inversion in a practical way. The third course will cover how to discover and use seams to enable testability and expand capabilities, while the last course will talk about sprout and wrap techniques for refactoring.

Sign up

Join the 1M+ learners on CodeSignal

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

Practical Application with an Order Processor

To make these concepts tangible, we'll use an order processor as our central example throughout the vast majority of our lesson and practice sessions. This practical application will serve as a playground for applying the techniques learned. By working through real-world scenarios, we'll gain a deeper understanding of how to implement these strategies in our own projects. This is one example of how the order processor might look: #include <vector> class Item {public: double Price; int Quantity;}; class Order {public: std::vector<Item> Items; double OrderTotal;}; class OrderProcessor {public: bool ProcessOrder(Order& order) {double totalAmount = 0; for (const auto& item : order.Items) {double itemPrice = item.Price * item.Quantity; totalAmount += itemPrice;} order.OrderTotal = totalAmount; return true;}}; Depending on the topic at hand, the order processor will be contrived to best demonstrate said topic, hopefully helping us grasp the concepts discussed.

C++

#include <vector>

class Item {
public:
    double Price;
    int Quantity;
};

class Order {
public:
    std::vector<Item> Items;
    double OrderTotal;
};

class OrderProcessor {
public:
    bool ProcessOrder(Order& order) {
        double totalAmount = 0;
        for (const auto& item : order.Items) {
            double itemPrice = item.Price * item.Quantity;
            totalAmount += itemPrice;
        }

        order.OrderTotal = totalAmount;
        return true;
    }
};