C++ Templates and Generic Programming Exercises

#include <iostream>
#include <string>

// 1. Function Template Definition
template <typename T>
T myMax(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // Testing with int
    int i1 = 5, i2 = 10;
    std::cout << "Max int: " << myMax(i1, i2) << std::endl;

    // Testing with double
    double d1 = 3.14, d2 = 2.718;
    std::cout << "Max double: " << myMax(d1, d2) << std::endl;

    // Testing with char
    char c1 = 'A', c2 = 'Z';
    std::cout << "Max char: " << myMax(c1, c2) << std::endl;

    // Testing with string
    std::string s1 = "Apple", s2 = "Banana";
    std::cout << "Max string: " << myMax(s1, s2) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• By using template <typename T>, the compiler can generate a specialized version of the myMax function for any data type T that supports the greater-than operator (>).
• When you call myMax(i1, i2), the compiler automatically deduces that T is int and creates a function myMax<int>.
• This approach eliminates the need to write separate, nearly identical functions for each data type.

#include <iostream>

// 1. Function Template Definition
template <typename T>
void mySwap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    // Testing with int
    int x = 10, y = 20;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    mySwap(x, y);
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    // Testing with float
    float f1 = 5.5f, f2 = 1.1f;
    std::cout << "Before swap: f1 = " << f1 << ", f2 = " << f2 << std::endl;
    mySwap(f1, f2);
    std::cout << "After swap: f1 = " << f1 << ", f2 = " << f2 << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The mySwap function is a classic use case for templates.
• By accepting the arguments as references (T&), the function avoids copying large objects and allows the function to modify the original variables passed from the calling scope.
• The template mechanism ensures that the temporary variable temp is of the exact type necessary for the variables being swapped, maintaining type safety while providing generic functionality.

#include <iostream>
#include <string>

// 1. Function Template Definition
template <typename T>
void printArray(const T arr[], int size) {
    std::cout << "[ ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << "]" << std::endl;
}

int main() {
    // Testing with int array
    int intArray[] = {1, 2, 3, 4, 5};
    int intSize = sizeof(intArray) / sizeof(intArray[0]);
    std::cout << "Int Array: ";
    printArray(intArray, intSize);

    // Testing with double array
    double doubleArray[] = {1.1, 2.2, 3.3};
    int doubleSize = sizeof(doubleArray) / sizeof(doubleArray[0]);
    std::cout << "Double Array: ";
    printArray(doubleArray, doubleSize);

    // Testing with string array
    std::string stringArray[] = {"hello", "world", "template"};
    int stringSize = sizeof(stringArray) / sizeof(stringArray[0]);
    std::cout << "String Array: ";
    printArray(stringArray, stringSize);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template allows a single function definition to handle arrays of different types (int, double, std::string, etc.).
• The type parameter T is substituted by the compiler based on the array type passed in. The use of const T arr[] ensures that the function cannot modify the elements of the array, which is a good practice for a display function.
• The array size must be passed explicitly because arrays often decay to pointers when passed to a function, losing their size information.

#include <iostream>
#include <string>

// 1. Function Template Definition
template <typename T>
int findInArray(const T arr[], int size, const T& target) {
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) {
            return i; // Found at index i
        }
    }
    return -1; // Not found
}

int main() {
    // Testing with int array
    int intArray[] = {10, 20, 30, 40, 50};
    int intSize = 5;
    int targetInt = 30;
    std::cout << "Index of " << targetInt << ": "
              << findInArray(intArray, intSize, targetInt) << std::endl;

    // Testing with double array
    double doubleArray[] = {1.1, 2.2, 3.3, 4.4};
    int doubleSize = 4;
    double targetDouble = 5.5;
    std::cout << "Index of " << targetDouble << ": "
              << findInArray(doubleArray, doubleSize, targetDouble) << std::endl;

    // Testing with string array
    std::string stringArray[] = {"alpha", "beta", "gamma"};
    int stringSize = 3;
    std::string targetString = "beta";
    std::cout << "Index of " << targetString << ": "
              << findInArray(stringArray, stringSize, targetString) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The findInArray template provides a generic linear search algorithm.
• It requires the type T to support the equality operator (==).
• The target value is passed as a const T& to avoid unnecessary copying. This is efficient for large user-defined types.
• If the search is successful, it returns the index; otherwise, it returns -1, which is a common convention to signal failure in array searches.

#include <iostream>

// 1. Function Template Definition
template <typename T>
T sum(const T arr[], int size) {
    T total = T(); // Initialize to zero (0 for numeric types)
    for (int i = 0; i < size; ++i) {
        total += arr[i];
    }
    return total;
}

int main() {
    // Testing with int array
    int intArray[] = {1, 2, 3, 4, 5};
    int intSize = 5;
    std::cout << "Sum of int array: " << sum(intArray, intSize) << std::endl; // Output: 15

    // Testing with double array
    double doubleArray[] = {1.5, 2.5, 3.0};
    int doubleSize = 3;
    std::cout << "Sum of double array: " << sum(doubleArray, doubleSize) << std::endl; // Output: 7

    // Testing with float array
    float floatArray[] = {0.1f, 0.2f, 0.3f};
    int floatSize = 3;
    std::cout << "Sum of float array: " << sum(floatArray, floatSize) << std::endl; // Output: 0.6

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template demonstrates how generic programming can implement common algorithms like accumulation.
• The line T total = T(); is a generic way to default-initialize the accumulator variable to zero, which works correctly for all built-in numeric types.
• This function requires the type T to support the addition-assignment operator (+=) and to be default-constructible.
• The template ensures that the sum calculation is performed using the correct type, avoiding potential data loss or overflow that could occur from mixing types.

#include <iostream>

// 1. Function Template Definition with two type parameters
template <typename T1, typename T2>
void compareAndPrint(T1 val1, T2 val2) {
    // Convert both to double for a reliable comparison
    double d1 = static_cast<double>(val1);
    double d2 = static_cast<double>(val2);

    std::cout << "Comparing " << val1 << " (" << d1 << ") and "
              << val2 << " (" << d2 << "): ";

    if (d1 > d2) {
        std::cout << val1 << " is greater." << std::endl;
    } else if (d2 > d1) {
        std::cout << val2 << " is greater." << std::endl;
    } else {
        std::cout << "They are equal (after cast)." << std::endl;
    }
}

int main() {
    // Comparing int and double
    compareAndPrint(10, 9.9);

    // Comparing char and int
    compareAndPrint('A', 60); // 'A' ASCII is 65

    // Comparing float and double
    compareAndPrint(100.5f, 100.49);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template demonstrates the use of multiple type parameters (T1 and T2). This is essential for generic functions that operate on inputs of different types.
• By casting both inputs to double before comparison, we ensure a consistent and robust comparison logic, especially when dealing with mixed numeric types like int and float. If we hadn’t cast, implicit type conversion rules might lead to unexpected results or warnings.

#include <iostream>
#include <string>

// 1. Function Template Definition
template <typename T>
T combine(const T& a, const T& b) {
    return a + b;
}

int main() {
    // Testing with int (Addition)
    int i_res = combine(5, 12);
    std::cout << "Int combine (5 + 12): " << i_res << std::endl;

    // Testing with double (Addition)
    double d_res = combine(3.5, 2.1);
    std::cout << "Double combine (3.5 + 2.1): " << d_res << std::endl;

    // Testing with std::string (Concatenation)
    std::string s1 = "Generic ", s2 = "Programming";
    std::string s_res = combine(s1, s2);
    std::cout << "String combine: " << s_res << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template showcases the power of Generic Programming in leveraging operator overloading. The combine function doesn’t know what the + operator does, only that it must exist for type T.
• For numeric types, + performs arithmetic addition. For std::string, the + operator is overloaded to perform concatenation.
• This single template definition works correctly for both use cases because the required operator behavior is defined for the respective types.

#include <iostream>

// 1. Using 'class' keyword (Older convention, still valid)
template <class T>
void printWithClass(const T& value) {
    std::cout << "Using 'class': " << value << std::endl;
}

// 2. Using 'typename' keyword (Modern convention)
template <typename T>
void printWithTypename(const T& value) {
    std::cout << "Using 'typename': " << value << std::endl;
}

int main() {
    printWithClass(100);
    printWithTypename(3.14);
    
    // Demonstrate a key scenario where 'typename' is REQUIRED 
    // (though not directly in the template parameter list here)
    // For example: typename T::nested_type member; 

    return 0;
}Code language: C++ (cpp)

Explanation:

• When declaring a type parameter in a template parameter list (e.g., <class T> or <typename T>), both class and typename are syntactically equivalent in C++. However, typename is generally preferred in modern C++ because it more clearly indicates that the parameter T is a placeholder for any type, including primitive types like int and types that are not classes.
• The compiler needs the typename keyword in a more complex scenario: when referring to a nested dependent type inside a template (e.g., typename T::iterator) to explicitly tell the compiler that iterator is a type, not a static member variable.

#include <iostream>
#include <cmath>

// 1. Function Template Definition
template <typename T>
T powerOfTwo(T n) {
    // For general numeric types, use std::pow
    return static_cast<T>(std::pow(2.0, static_cast<double>(n)));
}

// 2. Explicit Instantiation for float (Usually in a separate .cpp file)
template float powerOfTwo<float>(float n);

// Optional: Explicit Instantiation for int (to contrast)
template int powerOfTwo<int>(int n);

int main() {
    // The compiler will use the explicitly instantiated version for float
    float f_result = powerOfTwo(5.0f); 
    std::cout << "Power of two (float): " << f_result << std::endl; // Output: 32

    // The compiler will use the explicitly instantiated version for int
    int i_result = powerOfTwo(10);
    std::cout << "Power of two (int): " << i_result << std::endl; // Output: 1024
    
    // The compiler will implicitly instantiate for double 
    // (if an explicit version isn't available)
    double d_result = powerOfTwo(3.0);
    std::cout << "Power of two (double): " << d_result << std::endl; // Output: 8

    return 0;
}Code language: C++ (cpp)

Explanation:

• Explicit instantiation is a mechanism that forces the compiler to generate the code for a specific version of a template at a specific point, even if that version hasn’t been called yet.
• The line template float powerOfTwo<float>(float n); tells the compiler to create the powerOfTwo function where T is replaced by float.
• This is primarily used to separate template definitions and implementations into different files and to potentially reduce overall compilation time by centralizing template instantiation.

#include <iostream>
#include <typeinfo> // Used for typeid().name()

// 1. Function Template Definition (Generic Version)
template <typename T>
void process(T value) {
    std::cout << "Generic template version called for type: " << typeid(T).name()
              << " with value: " << value << std::endl;
}

// 2. Non-Template Overload (Specific Version)
void process(int value) {
    std::cout << "Non-template INT overload called with value: " << value << std::endl;
}

int main() {
    // Call 1: Passes an int - Calls the non-template overload
    int i = 5;
    process(i); 

    // Call 2: Passes a double - Calls the generic template version (T is deduced as double)
    double d = 3.14;
    process(d); 
    
    // Call 3: Explicitly calling the template for int 
    // This forces the generic version to be chosen, even though the overload exists.
    process<int>(10);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates template overloading and the compiler’s overload resolution rules. When process(i) is called with an int, the compiler finds two options: the generic template and the non-template process(int) overload.
• The non-template function is considered a better match because it requires no template instantiation and is a direct, exact match for the type.
• Therefore, the non-template overload is preferred and called. When process(d) is called with a double, only the generic template can create an exact match (process<double>), so the generic version is called.

#include <iostream>
#include <string>

// 1. Class Template Definition
template <typename T1, typename T2>
class Pair {
private:
    T1 first;
    T2 second;

public:
    // Constructor
    Pair(T1 a, T2 b) : first(a), second(b) {}

    // Accessors
    T1 getFirst() const {
        return first;
    }

    T2 getSecond() const {
        return second;
    }
};

int main() {
    // Pair of int and double
    Pair<int, double> p1(10, 5.5);
    std::cout << "Pair 1: " << p1.getFirst() << ", " << p1.getSecond() << std::endl;

    // Pair of string and char
    Pair<std::string, char> p2("Model", 'A');
    std::cout << "Pair 2: " << p2.getFirst() << ", " << p2.getSecond() << std::endl;

    // Pair of same type (e.g., int, int)
    Pair<int, int> p3(50, 25);
    std::cout << "Pair 3: " << p3.getFirst() << ", " << p3.getSecond() << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise introduces class templates with multiple type parameters. Unlike function templates where the compiler can often deduce types, class templates require explicit type specification (e.g., Pair<int, double>) when creating an object.
• The use of two type parameters, T1 and T2, makes the Pair class flexible enough to hold any combination of data types, a core concept in generic container design, similar to the standard library’s std::pair.

#include <iostream>
#include <vector>
#include <stdexcept>

// 1. Class Template Definition
template <typename T>
class Stack {
private:
    std::vector<T> data;

public:
    // Push operation
    void push(T element) {
        data.push_back(element);
    }

    // Pop operation
    T pop() {
        if (isEmpty()) {
            throw std::out_of_range("Stack::pop() on empty stack");
        }
        T top_element = data.back();
        data.pop_back();
        return top_element;
    }

    // Check if empty
    bool isEmpty() const {
        return data.empty();
    }
};

int main() {
    // Stack of integers
    Stack<int> intStack;
    intStack.push(10);
    intStack.push(20);
    std::cout << "Popped int: " << intStack.pop() << std::endl; // 20
    std::cout << "Is intStack empty? " << (intStack.isEmpty() ? "Yes" : "No") << std::endl;

    // Stack of strings
    Stack<std::string> stringStack;
    stringStack.push("Hello");
    stringStack.push("Templates");
    std::cout << "Popped string: " << stringStack.pop() << std::endl; // Templates
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• This template demonstrates how to create generic containers. By templating the Stack class, it can hold any data type T (integers, strings, custom objects, etc.) without rewriting the core LIFO (Last-In, First-Out) logic.
• The use of std::vector<T> provides a dynamic, type-safe internal storage mechanism. The pop() method includes error checking (throwing std::out_of_range) to handle the possibility of trying to remove an element from an empty stack, making the generic class robust.

#include <iostream>
#include <list>
#include <stdexcept>

// 1. Class Template Definition using std::list for efficient front operations
template <typename T>
class Queue {
private:
    std::list<T> data;

public:
    // Add to the back (Enqueue)
    void enqueue(T element) {
        data.push_back(element);
    }

    // Remove and return the front element (Dequeue)
    T dequeue() {
        if (isEmpty()) {
            throw std::out_of_range("Queue::dequeue() on empty queue");
        }
        T front_element = data.front();
        data.pop_front();
        return front_element;
    }

    // Check if empty
    bool isEmpty() const {
        return data.empty();
    }
};

int main() {
    // Queue of characters
    Queue<char> charQueue;
    charQueue.enqueue('A');
    charQueue.enqueue('B');
    charQueue.enqueue('C');
    std::cout << "Dequeued 1: " << charQueue.dequeue() << std::endl; // A
    std::cout << "Dequeued 2: " << charQueue.dequeue() << std::endl; // B

    return 0;
}Code language: C++ (cpp)

Explanation:

• Similar to the stack, the templated Queue class allows the underlying FIFO (First-In, First-Out) structure to be reused across different data types.
• By choosing std::list<T> internally, we ensure that both adding to the back (push_back) and removing from the front (pop_front) are efficient constant-time operations.
• This design exemplifies choosing the appropriate standard container within a generic structure to maintain performance guarantees for all types T.

#include <iostream>
#include <stdexcept>

// 1. Class Template Definition
template <typename T>
class GenericArray {
private:
    T* array_ptr;
    int size;

public:
    // Constructor
    GenericArray(int s) : size(s) {
        if (size <= 0) throw std::invalid_argument("Array size must be positive.");
        array_ptr = new T[size](); // () initializes to zero/default value
    }

    // Destructor (Crucial for dynamic memory management)
    ~GenericArray() {
        delete[] array_ptr;
    }

    // Overloaded subscript operator for read/write access
    T& operator[](int index) {
        if (index < 0 || index >= size) {
            throw std::out_of_range("Index out of bounds.");
        }
        return array_ptr[index];
    }
    
    // Getter for size (optional, but useful)
    int getSize() const {
        return size;
    }
};

int main() {
    // Array of 5 integers
    GenericArray<int> intArray(5);
    intArray[0] = 10;
    intArray[4] = 50;

    std::cout << "Int Array elements: ";
    for (int i = 0; i < intArray.getSize(); ++i) {
        std::cout << intArray[i] << " ";
    }
    std::cout << std::endl; // Output: 10 0 0 0 50 

    // Array of 3 doubles
    GenericArray<double> doubleArray(3);
    doubleArray[1] = 3.14;
    std::cout << "Double Array element at index 1: " << doubleArray[1] << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template is a simple example of a smart container that manages raw dynamic memory for any type T. By overloading operator[] to return a reference (T&), the syntax intArray[0] = 10; works naturally for both reading and writing.
• The most critical aspect is the Rule of Three/Five: since the class manages raw memory (new T[]), it must provide a custom destructor (delete[] array_ptr) to prevent memory leaks when the object goes out of scope.

#include <iostream>

// 1. Class Template Definition
template <typename T>
class Calculator {
private:
    T num1;
    T num2;

public:
    // Constructor
    Calculator(T n1, T n2) : num1(n1), num2(n2) {}

    // Arithmetic Operations
    T add() const {
        return num1 + num2;
    }

    T subtract() const {
        return num1 - num2;
    }

    T multiply() const {
        return num1 * num2;
    }

    T divide() const {
        // Simple division, assuming T handles division appropriately (e.g., int vs float)
        return num1 / num2;
    }
};

int main() {
    // Calculator for integers
    Calculator<int> intCalc(10, 3);
    std::cout << "Int Addition: " << intCalc.add() << std::endl;       // 13
    std::cout << "Int Division: " << intCalc.divide() << std::endl;     // 3 (integer division)

    // Calculator for doubles
    Calculator<double> doubleCalc(10.0, 3.0);
    std::cout << "Double Addition: " << doubleCalc.add() << std::endl; // 13.0
    std::cout << "Double Division: " << doubleCalc.divide() << std::endl; // 3.333...

    return 0;
}Code language: C++ (cpp)

Explanation:

• The Calculator template is a practical example of how templates ensure code reusability for algorithms independent of the data type.
• The logic for addition, subtraction, etc., is the same regardless of whether the numbers are integers or floating-point types. The template relies on the fact that the chosen type T provides meaningful definitions for the arithmetic operators. The resulting instantiated class (e.g., Calculator<int>) is completely type-safe.

#include <iostream>
#include <stdexcept>

// 1. Class Template Definition with a non-type parameter N
template <typename T, int N>
class FixedSizeArray {
private:
    T data[N]; // N must be known at compile time

public:
    // Constructor (initializes all elements to default value T())
    FixedSizeArray() {
        for (int i = 0; i < N; ++i) {
            data[i] = T(); 
        }
    }

    // Access element
    T get(int index) const {
        if (index < 0 || index >= N) {
            throw std::out_of_range("Index out of bounds.");
        }
        return data[index];
    }

    // Setter for simplicity
    void set(int index, T value) {
        if (index < 0 || index >= N) return;
        data[index] = value;
    }
    
    // Getter for size
    int size() const { return N; }
};

int main() {
    // Fixed array of 10 integers
    FixedSizeArray<int, 10> arr10;
    arr10.set(0, 100);
    arr10.set(9, 999);
    std::cout << "Array size: " << arr10.size() << std::endl;
    std::cout << "Element at index 0: " << arr10.get(0) << std::endl;

    // Fixed array of 5 doubles
    FixedSizeArray<double, 5> arr5;
    arr5.set(2, 3.14);
    std::cout << "Element at index 2: " << arr5.get(2) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template demonstrates the use of a non-type template parameter (int N). This allows the size of the container to be part of the type itself, determined at compile time.
• This is highly efficient as memory is allocated directly on the stack (if the object is not created using new) and bounds checking can potentially be optimized.
• Note that FixedSizeArray<int, 10> and FixedSizeArray<int, 5> are considered two completely separate and incompatible types by the compiler.

#include <iostream>

// 1. Class Template Definition
template <typename T>
class Node {
public:
    T data;
    Node<T>* next; // Pointer to the next node of the same type T

    // Constructor to initialize data and set next to null
    Node(T val) : data(val), next(nullptr) {}
};

int main() {
    // Creating integer nodes
    Node<int>* head = new Node<int>(10);
    Node<int>* second = new Node<int>(20);
    Node<int>* third = new Node<int>(30);

    // Linking the nodes
    head->next = second;
    second->next = third;

    // Traversing the list
    Node<int>* current = head;
    std::cout << "Integer List: ";
    while (current != nullptr) {
        std::cout << current->data << " ";
        current = current->next;
    }
    std::cout << std::endl;

    // Clean up memory
    delete head;
    delete second;
    delete third;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template demonstrates how a class template can be self-referential. The pointer Node<T>* next; within the Node<T> definition is key to forming the linked list structure.
• By templating the node, a single definition can create the building blocks for a list of integers, doubles, or complex user-defined objects, making the linked list structure highly generic.

#include <iostream>
#include <numeric>

// 1. Class Template Definition
template <typename T>
class MyVector {
private:
    T* array_ptr;
    int size;

public:
    // Define the iterator type (simplest form: a pointer to T)
    using iterator = T*;

    MyVector(int s) : size(s) {
        array_ptr = new T[size]();
    }
    ~MyVector() { delete[] array_ptr; }

    // Iterator interface functions
    iterator begin() {
        return array_ptr;
    }

    iterator end() {
        return array_ptr + size; // One past the last element
    }

    // Overloaded subscript operator for access
    T& operator[](int index) {
        return array_ptr[index];
    }
};

int main() {
    // Create a vector of 5 integers
    MyVector<int> vec(5);
    vec[0] = 1;
    vec[1] = 2;
    vec[2] = 3;
    vec[3] = 4;
    vec[4] = 5;

    // Use iterators (pointer arithmetic)
    std::cout << "Vector elements (using iterators): ";
    for (MyVector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Use std::accumulate with the custom iterators
    int sum = std::accumulate(vec.begin(), vec.end(), 0);
    std::cout << "Sum using std::accumulate: " << sum << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This template is a simplified view of how the Standard Template Library (STL) containers work. By defining a public nested type alias iterator (here, simply T*) and providing begin() and end() methods, the custom container becomes compatible with standard C++ algorithms like std::accumulate, std::sort, and the range-based for loop.
• This compatibility is the ultimate goal of generic programming in C++, allowing algorithms to work seamlessly across various container types.

#include <iostream>
#include <string>

// 1. Class Template Definition with default type T2 = int
template <typename T1, typename T2 = int>
class HoldingCell {
private:
    T1 value1;
    T2 value2;

public:
    // Constructor
    HoldingCell(T1 v1, T2 v2) : value1(v1), value2(v2) {}

    void display() const {
        std::cout << "Value 1 (Type " << typeid(T1).name() << "): " << value1 << std::endl;
        std::cout << "Value 2 (Type " << typeid(T2).name() << "): " << value2 << std::endl;
    }
};

int main() {
    // 1. Omitting T2: T2 defaults to int
    HoldingCell<std::string> cell1("ID", 42); 
    std::cout << "--- Cell 1 (Default int) ---" << std::endl;
    cell1.display();

    // 2. Explicitly providing T2: T2 is set to double
    HoldingCell<char, double> cell2('G', 9.81); 
    std::cout << "--- Cell 2 (Explicit double) ---" << std::endl;
    cell2.display();

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates default template arguments. This feature enhances the usability of class templates by allowing the user to omit less frequently changed type parameters, which is a form of syntactic sugar.
• When instantiating HoldingCell<std::string>, the compiler automatically substitutes int for T2. If a type is explicitly provided, as in HoldingCell<char, double>, the explicit type overrides the default argument.

#include <iostream>
#include <cstring>

// 1. Primary Class Template Definition
template <typename T>
class Printer {
public:
    void print(T value) const {
        std::cout << "Generic Printer: " << value << std::endl;
    }
};

// 2. Full Template Specialization for char*
template <>
class Printer<char*> {
public:
    void print(char* value) const {
        std::cout << "C-String Specialized Printer: \"" << value << "\"" << std::endl;
    }
};

int main() {
    // Uses the generic template (T is int)
    Printer<int> intPrinter;
    intPrinter.print(42);

    // Uses the generic template (T is double)
    Printer<double> doublePrinter;
    doublePrinter.print(3.14);
    
    // Uses the specialized template (T is char*)
    char* myString = strdup("Hello Templates");
    Printer<char*> charPtrPrinter;
    charPtrPrinter.print(myString);

    free(myString);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Full template specialization allows a programmer to provide a completely separate, custom implementation for a specific type while keeping the general template definition for all other types. In this case, the generic Printer works for most types, but the special handling required for C-style strings (char*) is implemented in template <> class Printer<char*>.
• This is necessary because raw C-style pointers are often printed as memory addresses by the generic implementation, whereas the user typically wants to see the actual string content.

#include <iostream>

// 1. Primary Function Template Definition
template <typename T>
void printValue(T value) {
    std::cout << "Generic Print: " << value << std::endl;
}

// 2. Explicit Template Specialization for bool
template <>
void printValue<bool>(bool value) {
    std::cout << "Boolean Specialization: " << (value ? "True" : "False") << std::endl;
}

int main() {
    // Calls the specialized function (int is 1, so True should be printed)
    bool b = 1;
    printValue(b); // Compiler deduces T is bool, selects the specialization

    // Calls the generic function (T is int)
    int i = 10;
    printValue(i);

    // Calls the generic function (T is float)
    float f = 10.5f;
    printValue(f);

    return 0;
}Code language: C++ (cpp)

Explanation:

Function templates use explicit specialization to provide unique logic for a specific type. While the generic version of printValue would print a boolean as its underlying integer value (0 or 1), the specialized version for bool provides the more readable textual representation (“True” or “False”). When printValue(b) is called, the compiler checks for the best match and selects the specialized printValue<bool> over generating the generic version.

#include <iostream>
#include <string>

// 1. Base Case: Stops the recursion when the pack is empty
void print_all() {
    std::cout << std::endl;
}

// 2. Recursive Case: Unpacks one argument and recurses with the rest
template <typename T, typename... Args>
void print_all(T first, Args... rest) {
    std::cout << first << " ";
    // Recursive call to handle the rest of the arguments
    print_all(rest...); 
}

int main() {
    // Calling with mixed types and various numbers of arguments
    std::cout << "--- Example 1 ---" << std::endl;
    print_all(10, 3.14, 'A', "hello world");

    std::cout << "--- Example 2 ---" << std::endl;
    print_all(true, 500);

    std::cout << "--- Example 3 (Empty) ---" << std::endl;
    print_all(); 

    return 0;
}Code language: C++ (cpp)

Explanation:

• Variadic templates (introduced in C++11) allow functions or classes to accept an arbitrary number of arguments of arbitrary types, captured in a parameter pack (Args...).
• The parameter pack must be unpacked using a recursive pattern: the recursive function takes the first argument (T first) and calls itself with the rest of the pack (rest...). The base function (the one with no arguments) serves as the stopping condition, preventing infinite recursion.