Idioms and Patterns

🏗️ C++ Best Practices: Idioms and Patterns

A Story-Driven Guide to Writing Clean, Professional C++ Code

🎭 The Master Builder’s Toolbox

Imagine you’re a master craftsman building houses. Over the years, you’ve discovered secret techniques that make your houses stronger, easier to fix, and more beautiful. These aren’t random tricks—they’re patterns that work every time.

In C++, experienced programmers have discovered similar patterns. We call them idioms. Today, you’ll learn six powerful ones that will make your code cleaner, safer, and more professional.

🔐 PIMPL Idiom: The Secret Room

What Is It?

PIMPL stands for “Pointer to IMPLementation”. It’s like building a house with a secret room that visitors can’t see.

The Story

Imagine your house has a beautiful front door (the public interface). Behind that door is a secret room where all the messy stuff happens—pipes, wires, machinery. Guests only see the nice door, not the chaos inside.

// Widget.h (What visitors see)
class Widget {
public:
    Widget();
    ~Widget();
    void doSomething();
private:
    class Impl;  // Secret room!
    Impl* pImpl; // Door to secret
};

// Widget.cpp (The secret room)
class Widget::Impl {
public:
    // All the messy details here
    int secretData;
    void secretFunction() { }
};

Widget::Widget()
    : pImpl(new Impl()) { }

Widget::~Widget() {
    delete pImpl;
}

void Widget::doSomething() {
    pImpl->secretFunction();
}

Why Use It?

1. Faster compilation - Change the secret room without rebuilding everything
2. Hide details - Users don’t need to know your secrets
3. Binary compatibility - Change internals without breaking existing programs

graph TD
    A["Public Header"] --> B["Pointer to Impl"]
    B --> C["Hidden Implementation"]
    C --> D["Private Data"]
    C --> E["Private Functions"]

🔄 Copy-and-Swap Idiom: The Safe Exchange

What Is It?

A foolproof way to copy objects. It’s like having a backup plan when moving into a new house.

The Story

Moving day! You want to swap houses with your friend. The safe way:

1. Build a temporary copy of your friend’s house
2. Swap everything at once
3. If anything fails, you still have your original!

class House {
    int* rooms;
    int count;
public:
    House(int n) : rooms(new int[n]),
                   count(n) { }

    ~House() { delete[] rooms; }

    // Copy constructor
    House(const House& other)
        : rooms(new int[other.count])
        , count(other.count) {
        std::copy(other.rooms,
                  other.rooms + count,
                  rooms);
    }

    // The magic swap function
    friend void swap(House& a, House& b) {
        using std::swap;
        swap(a.rooms, b.rooms);
        swap(a.count, b.count);
    }

    // Assignment using copy-and-swap
    House& operator=(House other) {
        swap(*this, other);
        return *this;
    }
};

The Magic ✨

• other is passed by value (makes a copy)
• We swap our guts with the copy
• The copy (now holding our old data) gets destroyed
• If copying fails, we never touched the original!

graph TD
    A["Original Object"] --> B["Make Copy"]
    B --> C["Swap Contents"]
    C --> D["Old Data Destroyed"]
    D --> E["Safe & Clean!"]

🧬 CRTP: The Inheritance Trick

What Is It?

CRTP = Curiously Recurring Template Pattern. A class inherits from a template of itself. Sounds weird? It’s actually genius!

The Story

Imagine a magic mirror that shows you yourself, but with superpowers. You look in the mirror, and it gives you abilities based on who YOU are.

// The magic mirror
template <typename Child>
class Mirror {
public:
    void gainPowers() {
        // Cast to actual child type
        Child& self = static_cast<Child&>(*this);
        self.usePower();  // Child's power!
    }
};

// You looking in the mirror
class Hero : public Mirror<Hero> {
public:
    void usePower() {
        std::cout << "Flying!\n";
    }
};

// Another person
class Wizard : public Mirror<Wizard> {
public:
    void usePower() {
        std::cout << "Magic spell!\n";
    }
};

Why Use It?

• Static polymorphism - No virtual function overhead
• Shared behavior - Base class gives features to children
• Compile-time magic - Faster than runtime virtual calls

Real Example: Counting Objects

template <typename T>
class Counter {
    static int count;
public:
    Counter() { ++count; }
    ~Counter() { --count; }
    static int getCount() {
        return count;
    }
};

template <typename T>
int Counter<T>::count = 0;

class Apple : public Counter<Apple> { };
class Orange : public Counter<Orange> { };

// Now each fruit tracks its own count!

👑 Singleton Pattern: The One True King

What Is It?

Ensures a class has only ONE instance in your entire program. Like a kingdom with only ONE king.

The Story

In the kingdom of Code, there can only be one king. No matter how many times you call for the king, you always get the same person.

class King {
private:
    // Private constructor - can't make new kings!
    King() { }

    // Delete copy and assignment
    King(const King&) = delete;
    King& operator=(const King&) = delete;

public:
    // The one way to meet the king
    static King& getInstance() {
        static King instance; // The one king
        return instance;
    }

    void decree(const std::string& law) {
        std::cout << "Royal decree: "
                  << law << "\n";
    }
};

// Usage
King::getInstance().decree("Be excellent!");

When to Use

• ✅ Database connections
• ✅ Configuration managers
• ✅ Logging systems
• ⚠️ Use sparingly - can make testing hard!

graph TD
    A["Request Instance"] --> B{Instance Exists?}
    B -->|No| C["Create Instance"]
    B -->|Yes| D["Return Existing"]
    C --> D

🏭 Factory Pattern: The Object Maker

What Is It?

A factory creates objects for you. You tell it what you want, and it builds the right thing.

The Story

You walk into a pet store. You say “I want a pet!” The store (factory) asks what kind, then gives you the right animal.

// Base class
class Pet {
public:
    virtual void speak() = 0;
    virtual ~Pet() = default;
};

// Different pets
class Dog : public Pet {
public:
    void speak() override {
        std::cout << "Woof!\n";
    }
};

class Cat : public Pet {
public:
    void speak() override {
        std::cout << "Meow!\n";
    }
};

// The Factory
class PetStore {
public:
    static std::unique_ptr<Pet>
    getPet(const std::string& type) {
        if (type == "dog")
            return std::make_unique<Dog>();
        if (type == "cat")
            return std::make_unique<Cat>();
        return nullptr;
    }
};

// Usage
auto myPet = PetStore::getPet("dog");
myPet->speak(); // Woof!

Why Use It?

• Hides complexity - You don’t need to know HOW pets are made
• Easy to extend - Add new pets without changing user code
• Centralized creation - One place controls all object making

graph TD
    A["Client"] --> B["Factory"]
    B --> C{What Type?}
    C -->|Dog| D["Create Dog"]
    C -->|Cat| E["Create Cat"]
    C -->|Bird| F["Create Bird"]
    D --> G["Return Pet"]
    E --> G
    F --> G

🚀 Copy Elision and RVO: The Teleportation Trick

What Is It?

RVO = Return Value Optimization. The compiler skips unnecessary copies. Objects seem to teleport directly to their destination!

The Story

Imagine ordering a pizza. The slow way: Cook makes pizza → puts in box → delivery person takes box → gives you box → you take pizza out.

The fast way (RVO): Cook teleports the pizza directly onto your plate!

class Pizza {
public:
    Pizza() {
        std::cout << "Making pizza\n";
    }
    Pizza(const Pizza&) {
        std::cout << "Copying pizza\n";
    }
};

// Without RVO: Make → Copy → Destroy
// With RVO: Make (directly at destination)
Pizza orderPizza() {
    return Pizza();  // Made directly!
}

int main() {
    Pizza myPizza = orderPizza();
    // Only prints "Making pizza"
    // No copy happened!
}

Named Return Value Optimization (NRVO)

Even named objects can be teleported!

Pizza orderSpecialPizza() {
    Pizza special;  // Named object
    // ... add toppings ...
    return special; // Still teleports!
}

When It Works

🚨 Common Mistake

// WRONG - prevents optimization!
Widget makeWidget() {
    Widget w;
    return std::move(w); // ❌ Bad!
}

// RIGHT - let compiler optimize
Widget makeWidget() {
    Widget w;
    return w; // ✅ Good!
}

🎯 Quick Summary

💪 You’ve Got This!

These patterns might seem complex at first, but they’re just smart shortcuts that experienced programmers have discovered over years of work.

Start with one pattern. Use it in a small project. Soon it will feel natural, and you’ll wonder how you ever coded without it!

Remember: Every expert was once a beginner who kept practicing. You’re on that same path! 🌟