===========================
Refactoring in C++
===========================

Definition
==========

Refactoring is the process of improving the internal structure of existing
code **without changing its external behavior**. The goal is to make C++
programs easier to read, maintain, and extend over time.

Why Refactor?
=============

- Improve code readability
- Reduce technical debt
- Make future changes easier
- Eliminate duplicated logic
- Simplify complex functions or classes
- Improve testability
- Increase overall maintainability

Key Principles
==============

- **Behavior must not change.**
- Small, incremental steps
- Continuous testing
- Understand *why* a refactor is needed before doing it
- Prefer clarity over cleverness

Common C++ Refactoring Techniques
=================================

Rename Variables and Functions
------------------------------

Use clear, descriptive names:

.. code-block:: cpp

   // Before
   int x;

   // After
   int maxConnectionCount;

Extract Functions
-----------------

Break large functions into smaller, reusable ones:

.. code-block:: cpp

   void processUser() {
       validateUser();
       saveUser();
       sendNotification();
   }

Eliminate Duplicate Code
------------------------

Move repeated logic into shared functions or utility classes.

Replace Magic Numbers with Constants
------------------------------------

.. code-block:: cpp

   const int MAX_RETRIES = 3;

Prefer RAII and Smart Pointers
------------------------------

Use ``std::unique_ptr`` and ``std::shared_ptr`` instead of manual ``new``/``delete``.

Simplify Conditionals
---------------------

.. code-block:: cpp

   // Before
   if (status == 1 || status == 2 || status == 3)

   // After
   bool isActive = (status >= 1 && status <= 3);

Encapsulate Data
----------------

Replace raw public fields with getters/setters or class methods
to enforce invariants.

Break Up Large Classes (Class Decomposition)
--------------------------------------------

Split classes that have too many responsibilities
(related to the Single Responsibility Principle).

Use Standard Library Algorithms
-------------------------------

Replace manual loops with STL algorithms:

.. code-block:: cpp

   std::sort(vec.begin(), vec.end());

When to Refactor?
=================

- Before adding new features
- When fixing bugs
- When code becomes hard to understand
- During regular cleanup cycles
- When reviewing code (PR feedback)

When *Not* to Refactor
=======================

- When you do not understand the existing code behavior
- When tests are missing (add tests first)
- When deadlines require new features immediately
- When refactoring would introduce unnecessary churn

Refactoring Tools for C++
==========================

- `clang-tidy <https://clang.llvm.org/extra/clang-tidy/>`_
- `cppcheck <http://cppcheck.sourceforge.net/>`_
- IDE support: CLion, Visual Studio, VSCode extensions
- Automatic formatting: ``clang-format``

Refactoring Checklist
=====================

- [ ] Code still compiles
- [ ] All tests pass
- [ ] Behavior unchanged
- [ ] Names are clear and expressive
- [ ] No duplicate logic
- [ ] Functions/classes have a single responsibility
- [ ] Code is easier to read than before
- [ ] Document any structural changes