Template Basics

🧙‍♂️ C++ Templates: The Magic Cookie Cutter Factory

Imagine you have ONE cookie cutter, but it can magically make cookies from ANY dough—chocolate, vanilla, strawberry, or even pizza dough! That’s what templates are in C++. One blueprint, infinite possibilities.

🎯 What Are Templates?

Think of templates like a magic recipe card. Instead of writing separate recipes for chocolate cake, vanilla cake, and strawberry cake, you write ONE recipe with a blank for the flavor:

"Make a ___ cake"

Fill in the blank with any flavor, and boom—you have a new cake recipe!

In C++, templates let you write code ONCE that works with any data type—numbers, words, custom objects, anything!

📦 The Six Magic Spells of Templates

graph TD
    A["🧙‍♂️ Templates"] --> B["Function Templates"]
    A --> C["Class Templates"]
    A --> D["Template Parameters"]
    A --> E["Non-Type Parameters"]
    A --> F["Default Arguments"]
    A --> G["Type Deduction"]

    B --> B1["One function for all types"]
    C --> C1["One class for all types"]
    D --> D1["The type placeholder"]
    E --> E1["Use values not types"]
    F --> F1["Automatic fallbacks"]
    G --> G1["Compiler figures it out"]

🔮 Spell #1: Function Templates

The Story

You’re a mail carrier. You deliver packages. Do you need to learn a DIFFERENT way to deliver for each type of package? No! You pick it up and deliver it—whether it’s a book, a toy, or a pizza.

Function templates work the same way. One function that handles ANY type.

The Old Way (Boring & Repetitive)

int addNumbers(int a, int b) {
    return a + b;
}

double addDecimals(double a, double b) {
    return a + b;
}

// Same logic, written TWICE! 😫

The Template Way (Magic! ✨)

template<typename T>
T add(T a, T b) {
    return a + b;
}

// Now use it with ANYTHING:
add(5, 3);        // Works with int
add(2.5, 1.7);    // Works with double
add('A', ' ');    // Works with char!

🔑 Key Parts:

• template<typename T> → “Hey compiler, T is a placeholder for ANY type”
• T → The magic blank that gets filled in later
• You can name it anything: T, Type, DataType, Pizza 🍕

🏗️ Spell #2: Class Templates

The Story

Imagine a magic box that can store ANYTHING. Not just apples. Not just books. Literally anything—and it remembers what’s inside!

That’s a class template. One box design, infinite possibilities.

Example: A Universal Storage Box

template<typename T>
class Box {
private:
    T item;

public:
    void store(T thing) {
        item = thing;
    }

    T retrieve() {
        return item;
    }
};

Using Your Magic Box

Box<int> numberBox;
numberBox.store(42);

Box<string> wordBox;
wordBox.store("Hello!");

Box<double> priceBox;
priceBox.store(9.99);

💡 Real World Example

Ever used vector<int> or vector<string>? That’s a class template! The <int> part fills in the blank for what type goes inside.

🎭 Spell #3: Template Parameters

The Story

Template parameters are like fill-in-the-blanks in a Mad Libs game. You write the story with blanks, and someone fills them in later.

Types of Blanks (Parameters)

graph TD
    A["Template Parameters"] --> B["Type Parameters"]
    A --> C["Non-Type Parameters"]
    A --> D["Template Template Parameters"]

    B --> B1["typename T<br>class T"]
    C --> C1["int N<br>size_t Size"]
    D --> D1["template<...> class Container"]

Simple Type Parameter

template<typename T>
void print(T value) {
    cout << value;
}

Multiple Parameters

template<typename K, typename V>
class Pair {
    K key;
    V value;
};

// Usage:
Pair<string, int> age;  // name → age
Pair<int, double> data; // id → score

🎯 Remember:

• typename and class mean the SAME thing here
• You can have as many parameters as you need
• Each parameter is like a new blank to fill in

🔢 Spell #4: Non-Type Template Parameters

The Story

Sometimes you don’t want to fill in a TYPE—you want to fill in a NUMBER or VALUE. Like saying “make me a box that holds exactly 5 things.”

The Magic of Fixed Sizes

template<typename T, int SIZE>
class FixedArray {
    T data[SIZE];  // Size known at compile time!

public:
    int length() {
        return SIZE;
    }
};

// Usage:
FixedArray<int, 5> fiveNumbers;
FixedArray<char, 100> buffer;

What Can Be Non-Type Parameters?

• ✅ Integers (int, size_t, long)
• ✅ Pointers
• ✅ References
• ✅ Enums
• ❌ Floating-point numbers (in older C++)
• ❌ Strings (directly)

💡 Real World

// std::array uses non-type parameter!
array<int, 10> tenItems;

🎁 Spell #5: Template Default Arguments

The Story

Imagine ordering food. “I’ll have a burger.” The waiter assumes you want fries unless you say otherwise. That’s a default.

Templates can have defaults too!

Function Template Defaults

template<typename T = int>
T getZero() {
    return T(0);
}

// Usage:
getZero();       // Returns int 0
getZero<double>(); // Returns double 0.0

Class Template Defaults

template<typename T = int, int SIZE = 10>
class SmartArray {
    T data[SIZE];
};

// Usage:
SmartArray<> defaultArray;        // int, size 10
SmartArray<double> doubleArray;   // double, size 10
SmartArray<char, 256> buffer;     // char, size 256

⚠️ Important Rule

Default arguments go right to left:

// ✅ CORRECT
template<typename A, typename B = int>

// ❌ WRONG - Can't skip!
template<typename A = int, typename B>

🔍 Spell #6: Template Type Deduction

The Story

You hand someone an apple. They don’t need you to say “this is an apple.” They can SEE it’s an apple. That’s type deduction—the compiler figures out the type by LOOKING at what you give it.

The Magic in Action

template<typename T>
void show(T value) {
    cout << value;
}

// Compiler deduces the type:
show(42);      // T = int (you gave an int)
show(3.14);    // T = double (you gave a double)
show("Hi!");   // T = const char* (you gave a string)

No Need to Specify!

// These are the same:
show<int>(42);  // Explicit
show(42);       // Deduced ✨ (easier!)

⚠️ When Deduction Gets Confused

template<typename T>
T add(T a, T b) {
    return a + b;
}

add(5, 3.14);  // ❌ ERROR! Is T int or double?
add<double>(5, 3.14);  // ✅ You tell it

🎯 Deduction Rules (Simplified)

1. Compiler looks at the arguments you pass
2. Figures out what type makes sense
3. If confused → error (you help by specifying)

🏆 Putting It All Together

// A complete example using everything!

template<typename T = int, int SIZE = 5>
class MagicBag {
    T items[SIZE];
    int count = 0;

public:
    void add(T item) {
        if (count < SIZE) {
            items[count++] = item;
        }
    }

    T get(int index) {
        return items[index];
    }

    int capacity() {
        return SIZE;
    }
};

// Usage:
MagicBag<> defaultBag;           // int, 5 items
MagicBag<string, 100> wordBag;   // string, 100 items

🌟 Quick Summary

🚀 Why Templates Are Amazing

1. Write Once, Use Forever → No repetitive code
2. Type Safe → Compiler catches mistakes
3. Fast → No runtime overhead
4. Flexible → Works with any type

🎉 You did it! You now understand the magic of C++ templates. You can write ONE piece of code that works with ANY type. That’s real programming power!

Remember: Templates are like magic cookie cutters—one tool, infinite creations! 🍪✨