Eliminating Code Duplication and Refactoring Magic Numbers in C++

Introduction and Context Setting

Welcome to our lesson on eliminating duplicated code and enhancing maintainability through method extraction and refactoring magic numbers in C++ . Writing clean and maintainable code is crucial in modern software development, and refactoring plays a key role in achieving these goals. This lesson focuses on identifying duplicate code segments and restructuring them to improve readability and maintainability. Throughout this course, we will be using C++, a powerful object-oriented programming language known for its performance and versatility. We will employ Google Test, a widely-used testing framework, to facilitate test-driven development (TDD), along with Google Mock, a valuable tool for creating mock objects during testing. This lesson builds upon an existing ShoppingCart example to dive into the Refactor step of the Red-Green-Refactor cycle. Let's begin by identifying and refactoring duplicated code to improve the quality of the codebase.

What are Code Smells and How Do You Eliminate Them?

Before we proceed to specific "smells," it's important to understand what "code smells" are. Code smells are indicators in the code suggesting deeper problems, such as poorly structured code or potential defects, though they aren't bugs themselves. Common examples include duplicate code, long methods, and magic numbers. These signals can hinder code readability and maintainability, and may eventually lead to significant issues. Refactoring patterns provide structured techniques to address these code smells, improving the overall quality of the codebase while maintaining its behavior. By employing these patterns, we can systematically transform problematic sections into cleaner, more efficient code. In this lesson, we'll target duplications by leveraging refactoring patterns such as method extraction and refactoring magic numbers to enhance the clarity and adaptability of our code. Trust in your tests to ensure existing functionality remains unaffected!

Understanding Code Duplication

"Code Duplication" is a code smell that occurs when similar or identical code segments are repeated across a codebase, leading to maintenance difficulties and bugs. Consider constant values distributed throughout a codebase without clear labeling. This mirroring phenomenon complicates updates or adjustments, requiring changes in multiple places, increasing the risk of errors. Adhering to the DRY (Don't Repeat Yourself) principle ensures each piece of knowledge has a single, unambiguous representation within the system. This leads to better maintainability and understandability, reducing troubleshooting and debugging efforts. Remember, refactoring to eliminate code duplication aligns perfectly with our TDD workflow, ensuring minimal disruption to existing functionalities.

Join the 1M+ learners on CodeSignal

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

Refactor - Optimize the Implementation

During refactoring, we integrate calculateSubtotal into the ShoppingCart class for broader adoption across all methods needing this logic. With the TDD mindset, all functionality remains intact while elevating code quality.

C++

#include <vector>
#include <string>

class CartItem {
public:
    std::string Name;
    double Price;
    int Quantity;
};

class ShoppingCart {
private:
    std::vector<CartItem> items;

public:
    void addItem(const std::string& name, double price, int quantity) {
        items.push_back(CartItem{name, price, quantity});
    }

    double calculateTotal() {
        double total = 0;

        for (const auto& item : items) {
            double itemTotal = item.Price * item.Quantity;

            if (item.Quantity >= 5) {
                itemTotal *= 0.9; // 10% discount
            }

            total += itemTotal;
        }

        return total;
    }

    double calculateTotalWithStudentDiscount() {
        double total = 0;

        for (const auto& item : items) {
            double itemTotal = item.Price * item.Quantity;

            if (item.Quantity >= 5) {
                itemTotal *= 0.9; // 10% discount
            }

            total += itemTotal;
        }

        // Apply student discount
        return total * 0.85; // 15% student discount
    }
};

#include <vector>
#include <string>

class CartItem {
public:
    std::string Name;
    double Price;
    int Quantity;
};

class ShoppingCart {
private:
    std::vector<CartItem> items;

public:
    void addItem(const std::string& name, double price, int quantity) {
        items.push_back(CartItem{name, price, quantity});
    }

    double calculateTotal() {
        double total = 0;

        for (const auto& item : items) {
            double itemTotal = item.Price * item.Quantity;

            if (item.Quantity >= 5) {
                itemTotal *= 0.9; // 10% discount
            }

            total += itemTotal;
        }

        return total;
    }

    double calculateTotalWithStudentDiscount() {
        double total = 0;

        for (const auto& item : items) {
            double itemTotal = item.Price * item.Quantity;

            if (item.Quantity >= 5) {
                itemTotal *= 0.9; // 10% discount
            }

            total += itemTotal;
        }

        // Apply student discount
        return total * 0.85; // 15% student discount
    }
};

The repetitive logic resides within the calculateTotal and calculateTotalWithStudentDiscount methods.

Refactor: Extract Method

We'll extract a method called calculateSubtotal, which can be used by calculateTotal and calculateTotalWithStudentDiscount to eliminate duplication.

C++

#include <vector>
#include <string>

class CartItem {
public:
    std::string Name;
    double Price;
    int Quantity;
};

class ShoppingCart {
private:
    std::vector<CartItem> items;

    double calculateSubtotal() const {
        double total = 0;

        for (const auto& item : items) {
            double itemTotal = item.Price * item.Quantity;

            if (item.Quantity >= 5) {
                itemTotal *= 0.9; // 10% discount
            }

            total += itemTotal;
        }

        return total;
    }

public:
    void addItem(const std::string& name, double price, int quantity) {
        items.push_back(CartItem{name, price, quantity});
    }

    double calculateTotal() const {
        return calculateSubtotal();
    }

    double calculateTotalWithStudentDiscount() const {
        double subtotal = calculateSubtotal();

        // Apply student discount
        return subtotal * 0.85; // 15% student discount
    }
};

#include <vector>
#include <string>

class CartItem {
public:
    std::string Name;
    double Price;
    int Quantity;
};

class ShoppingCart {
private:
    std::vector<CartItem> items;

    double calculateSubtotal() const {
        double total = 0;

        for (const auto& item : items) {
            double itemTotal = item.Price * item.Quantity;

            if (item.Quantity >= 5) {
                itemTotal *= 0.9; // 10% discount
            }

            total += itemTotal;
        }

        return total;
    }

public:
    void addItem(const std::string& name, double price, int quantity) {
        items.push_back(CartItem{name, price, quantity});
    }

    double calculateTotal() const {
        return calculateSubtotal();
    }

    double calculateTotalWithStudentDiscount() const {
        double subtotal = calculateSubtotal();

        // Apply student discount
        return subtotal * 0.85; // 15% student discount
    }
};

Introduction and Context Setting

What are Code Smells and How Do You Eliminate Them?

Understanding Code Duplication

Join the 1M+ learners on CodeSignal

Example: Extracting Methods

Refactor - Optimize the Implementation

Refactor: Extract Method

Example: Refactoring Magic Numbers

Refactor: Extract Magic Numbers

Review, Summary, and Preparation for Practice