Refactoring Complex Function Signatures in C++ with Parameter Objects

Introduction and Overview

Welcome to the third lesson of our course, where we explore the concept of the Parameter Object to address a common code smell: complex function signatures. Throughout this course, we work on eliminating code smells to enhance the readability, maintainability, and scalability of your codebase, with a strong emphasis on Test Driven Development (TDD) . In our previous lessons, we addressed code smells such as duplicated code using the Extract Method technique to manage long methods. Today, we confront the code smell associated with long parameter lists and introduce the Parameter Object as an effective solution. We will utilize C++'s object-oriented capabilities and use Google Test and Google Mock for testing. Understanding and mastering the TDD cycle — Red, Green, Refactor — will be critical as we work to eliminate code smells in this lesson.

Why Long Parameter Lists are a Code Smell

Long parameter lists are considered a code smell because they complicate function signatures, making the code harder to read, maintain, and test. This complexity arises from several issues: Readability : When a function has too many parameters, it becomes challenging to understand what each parameter represents without referring to the documentation or function implementation. It clutters the function definition and makes the code less intuitive. Maintainability : Modifying a function with a long parameter list becomes cumbersome. Adding or removing parameters can lead to errors in existing function calls across the codebase, increasing the risk of bugs. Error-Prone : It's easy to mix up or misorder parameters, especially when their types are similar. Even with type-checking, logical errors can occur if parameters are passed in the wrong order or are misunderstood. Testing Challenges : Long parameter lists make writing and maintaining tests more difficult, as test cases need to supply many arguments. This complexity can discourage thorough testing and make tests brittle against changes. Lack of Cohesion : A long list of parameters may indicate that not all parameters are related or that the function is doing too much, violating the single responsibility principle. By recognizing long parameter lists as a code smell and refactoring them into a Parameter Object, we can improve how we work with and maintain our code, making it more robust and easier to understand.

Join the 1M+ learners on CodeSignal

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

Refactor: Introduce Parameter Objects, Reorder, and Defaults

C++

#include <vector>
#include <string>

struct ScoreWeights {
    double exam;
    double homework;
    double attendance;
};

struct CoursePolicy {
    int bonusPointsPerActivity;
    double passingThreshold;
};

class ExamProcessor {
public:
    ExamResult ProcessExamScore(
        std::string courseCode,
        
        // Individual Performance
        double examScore,
        bool isHomeworkComplete = true,
        int attendanceScore = 3,
        std::vector<std::string> bonusActivities = {},
        bool isRetake = false,
        
        // Configuration
        const ScoreWeights* scoreWeights = nullptr,
        const CoursePolicy* coursePolicy = nullptr
    ) {
        // Default objects
        ScoreWeights defaultScoreWeights = {0.5, 0.3, 0.2};
        CoursePolicy defaultCoursePolicy = {10, 60};

        // Use defaults if null
        scoreWeights = scoreWeights ? scoreWeights : &defaultScoreWeights;
        coursePolicy = coursePolicy ? coursePolicy : &defaultCoursePolicy;

        // Implementation
    }
};

#include <vector>
#include <string>

struct ScoreWeights {
    double exam;
    double homework;
    double attendance;
};

struct CoursePolicy {
    int bonusPointsPerActivity;
    double passingThreshold;
};

class ExamProcessor {
public:
    ExamResult ProcessExamScore(
        std::string courseCode,
        
        // Individual Performance
        double examScore,
        bool isHomeworkComplete = true,
        int attendanceScore = 3,
        std::vector<std::string> bonusActivities = {},
        bool isRetake = false,
        
        // Configuration
        const ScoreWeights* scoreWeights = nullptr,
        const CoursePolicy* coursePolicy = nullptr
    ) {
        // Default objects
        ScoreWeights defaultScoreWeights = {0.5, 0.3, 0.2};
        CoursePolicy defaultCoursePolicy = {10, 60};

        // Use defaults if null
        scoreWeights = scoreWeights ? scoreWeights : &defaultScoreWeights;
        coursePolicy = coursePolicy ? coursePolicy : &defaultCoursePolicy;

        // Implementation
    }
};

Notice the following:

Re-ordering parameters: Parameters have been reorganized in the function signature to group related values, enhancing readability and logical flow. For instance, parameters related to the course information are grouped together, separate from those related to individual performance or scoring configurations.
Parameter Objects: The function has been refactored to utilize two parameter objects (ScoreWeights and CoursePolicy), which encapsulate multiple related parameters into a single cohesive object. This reduces complexity in the function signature and clarifies its intent.
Defaults: Default values have been assigned to certain parameters, such as isHomeworkComplete and attendanceScore, providing sensible defaults when those values are not explicitly specified, simplifying function calls and reducing potential errors.

Introduction and Overview

Why Long Parameter Lists are a Code Smell

Join the 1M+ learners on CodeSignal

Example: Long Parameter List

Confusing Tests

Refactor: Introduce Parameter Objects, Reorder, and Defaults

Less Confusing Tests

Real-world Application

Summary and Practice Preparation