Refactoring Examples

1. Data:
   1. Do not leave unnecessary variables lying around (Before versus After)
   2. Use symbolic instead of literal constants (Before versus After)
   3. Use boolean literal constants (C++) (Before versus After)
   4. Keep data types consistent (Before versus After)
2. Expressions:
   1. Avoid self-assignment (Before versus After)
   2. Boolean variable as condition (Before versus After)
   3. Combine discrete values into ranges (Before versus After)
   4. Unary assignment is self-sufficient (Before versus After)
3. if/if-else:
   1. Factor out code from if- and else- clauses (Before versus After)
   2. Avoid redundant conditions (Before versus After)
   3. Avoid empty else (Before versus After)
   4. Combine if-else statements (Before versus After)
   5. Code inversion (Before versus After)
4. Nested if/if-else:
   1. Avoid multiple ifs instead of nested if-else (Before versus After)
   2. Avoid redundant conditions involving independent variables (Before versus After)
   3. Avoid nested if-else for independent variables (Before versus After)
5. switch:
   1. Factor out code from switch (Before versus After)
   2. Combine cases in switch (Before versus After)
   3. Include default for error cases (Before versus After)
6. loops:
   1. Write well-formed loops:
      1. Do not use third party variables (Before versus After)
      2. Avoid infinite loop with break (Before versus After)
      3. Avoid empty for loops (Before versus After)
   2. while loop:
      1. Don't rig the condition variable for the first iteration (Before versus After)
      2. Move post-loop code out of the loop (Before versus After)
   3. do-while for validation:
      1. Don't do work inside validation loop (Before versus After)
      2. Don't use one loop to validate two or more inputs (Before versus After)
   4. Use the correct loop:
      1. Don't use do-while instead of while (Before versus After)
      2. Use do-while for validation (Before versus After)
      3. Use for loop when using a counter (Before versus After)
7. Control structures:
   1. Eliminate unnecessary control structures (Before versus After)
8. Functions:
   1. Parameter Passing:
      1. Do not pass unnecessary parameters (Before versus After)
      2. Prioritize local variables over parameters (Before versus After)
      3. Prioritize passing by value over reference (Before versus After)
      4. Avoid passing a single parameter by reference (Before versus After)
      5. Pass an element instead of an array and subscript (Before versus After)
      6. Use consistent order of parameters (Before versus After)
      7. If you pass some parameters by reference, pass all necessary parameters by reference (Before versus After)
   2. Return value
      1. Unnecessary return value (Before versus After)
      2. Returning data that was passed by reference (Before versus After)
   3. Body:
      1. Update variables within their scope (Before versus After)
      2. When appropriate, use guards clauses instead of nested if-else: (Before versus After)
      3. One function, one purpose: (Before versus After)
      4. Don't use the same name for a local variable as the function (Before versus After)
      5. Parameterize functions (Before versus After)
   4. Recursion:
      1. Use loops instead of recursion when possible (Before versus After)
      2. Avoid dragon-tail recursion (Before versus After)
9. Classes:
   1. Avoid declaring data members public (Before versus After)
   2. Prioritize function variable over class variable (Before versus After)
   3. Avoid dependent data members or mutators for them (Before versus After)
10. Inheritance:
    1. Migrate:
       1. Common data members to base class: (Before versus After)
       2. Common member functions to base class: (Before versus After)
    2. Don't re-declare:
       1. Base class data member in derived class (Before versus After)
       2. Base class member function in derived class (Before versus After)
    3. Call base class function in overriding derived class function:
       1. At the start: (Before versus After)
       2. Template method: (Before versus After)
    4. Use polymorphic behavior instead of if-else in client (Before versus After)