How to Correct Code Smell Issues in C++

1. Common Yet Easily Ignored Bad Code Smells

1. 1. Inconsistent Code Style: In the same project, some code uses C-style functions and syntax, while another part heavily adopts C++ object-oriented features. This mixed style can make the code look chaotic. For example, in one file, there is a mix of data manipulation using structures and C functions, along with code that uses C++ classes and member functions to achieve similar functionality.

// C-style operations on structures
struct Point {
    int x;
    int y;
};

void movePointC(Point* p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

// C++ style operations on classes
class PointCpp {
public:
    int x;
    int y;
    void move(int dx, int dy) {
        x += dx;
        y += dy;
    }
};

1. 2. Overly Complex Expressions: Writing overly complex single-line expressions may save a few lines of code but greatly reduces readability. For instance, nesting multiple logical operators and function calls in conditional statements.

if (calculateValue() > 10 && anotherFunction() == "specificValue" || thirdFunction() < 5) {
    // Perform some operations
}

1. 3. Improper Memory Management: When using dynamic memory allocation (such as new and delete), failing to follow the correct pairing rules or not considering memory release in exceptional cases can lead to memory leaks or program crashes.

void someFunction() {
    int* ptr = new int[10];
    // Returning without freeing memory
    return;
}

2. Strategies to Correct These Code Smell Issues

1. 1. Unify Code Style: Clearly define the main programming paradigm adopted for the project. If C++ is the primary focus, try to minimize unnecessary C-style code. In the example above with Point, consistently use C++ classes to handle data.

class Point {
public:
    int x;
    int y;
    void move(int dx, int dy) {
        x += dx;
        y += dy;
    }
};

1. 2. Break Down Complex Expressions: Decompose complex expressions into multiple simple steps, using temporary variables to store intermediate results. This not only improves readability but also facilitates debugging.

int value = calculateValue();
std::string result = anotherFunction();
int thirdResult = thirdFunction();
if (value > 10 && result == "specificValue" || thirdResult < 5) {
    // Perform some operations
}

1. 3. Proper Memory Management: Use smart pointers (such as std::unique_ptr, std::shared_ptr) instead of raw pointers for dynamic memory management. They automatically release memory at the end of the object’s lifecycle, avoiding the risks associated with manual memory management.

#include <memory>
void someFunction() {
    std::unique_ptr<int[]> ptr(new int[10]);
    // No need to manually release memory; it will automatically be released when going out of scope
}</int[]></memory>

By focusing on and correcting these uncommon yet important code smell issues, we can further enhance the quality of C++ code. Maintaining sensitivity to code style during daily programming, regularly conducting code reviews, and self-reflection will help us develop good programming habits and create high-quality, maintainable C++ projects.