C++ Templates & Generics Quiz

template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    int x = max(5, 3);        // T = int
    double y = max(5.5, 3.2); // T = double
    return 0;
}

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

int main() {
    print(42);      // T deduced as int
    print(3.14);    // T deduced as double
    print("hello"); // T deduced as const char*
    return 0;
}

template<typename T>
class Stack {
private:
    std::vector<T> data;
public:
    void push(T value) { data.push_back(value); }
    T pop() {
        T val = data.back();
        data.pop_back();
        return val;
    }
};

int main() {
    Stack<int> intStack;
    intStack.push(42);
    
    Stack<std::string> stringStack;
    stringStack.push("hello");
    return 0;
}

template<typename T>
T square(T x) { return x * x; }

int main() {
    int result1 = square(5);     // Instantiates square<int>
    double result2 = square(3.5); // Instantiates square<double>
    return 0;
}

// Compiler generates:
// int square<int>(int x) { return x * x; }
// double square<double>(double x) { return x * x; }

template<typename T, size_t N>
class Array {
private:
    T data[N];  // N is compile-time constant
public:
    T& operator[](size_t index) { return data[index]; }
    size_t size() const { return N; }
};

int main() {
    Array<int, 5> arr;  // N = 5
    arr[0] = 42;
    std::cout << arr.size() << std::endl;  // 5
    return 0;
}

// General template
template<typename T>
class Printer {
public:
    void print(T value) {
        std::cout << "Generic: " << value << std::endl;
    }
};

// Specialization for bool
template<>
class Printer<bool> {
public:
    void print(bool value) {
        std::cout << "Bool: " << (value ? "true" : "false") << std::endl;
    }
};

int main() {
    Printer<int> p1;
    p1.print(42);     // Uses general template
    
    Printer<bool> p2;
    p2.print(true);    // Uses specialization
    return 0;
}

// General template
template<typename T, typename U>
class Pair {
public:
    T first;
    U second;
};

// Partial specialization for when both types are the same
template<typename T>
class Pair<T, T> {
public:
    T first;
    T second;
    bool same() const { return first == second; }
};

int main() {
    Pair<int, double> p1;  // Uses general template
    Pair<int, int> p2;     // Uses partial specialization
    p2.first = 5;
    p2.second = 5;
    std::cout << p2.same() << std::endl;  // true
    return 0;
}

template<typename T>
class HasSize {
    typedef char Yes;
    typedef long No;
    
    template<typename U> static Yes test(decltype(&U::size));
    template<typename U> static No test(...);
    
public:
    static const bool value = sizeof(test<T>(0)) == sizeof(Yes);
};

class Container {
public:
    size_t size() const { return 0; }
};

int main() {
    std::cout << HasSize<Container>::value << std::endl;  // true
    std::cout << HasSize<int>::value << std::endl;       // false
    return 0;
}

template<typename... Args>
void printAll(Args... args) {
    // Fold expression (C++17)
    (std::cout << ... << args) << std::endl;
}

// Recursive expansion
void printAll() {}  // Base case

template<typename T, typename... Args>
void printAll(T first, Args... rest) {
    std::cout << first << " ";
    printAll(rest...);  // Recurse with remaining args
}

int main() {
    printAll(1, 2.5, "hello", true);  // Prints: 1 2.5 hello 1
    return 0;
}

// Compile-time factorial
template<size_t N>
struct Factorial {
    static const size_t value = N * Factorial<N-1>::value;
};

template<>
struct Factorial<0> {
    static const size_t value = 1;
};

int main() {
    std::cout << Factorial<5>::value << std::endl;  // 120 (computed at compile-time)
    return 0;
}

template<typename T>  // Preferred
class Container {
    // ...
};

template<class U>     // Equivalent
class Container2 {
    // ...
};

// Inside templates, typename disambiguates dependent names
template<typename T>
void func() {
    typename T::iterator it;  // typename required
    // T::iterator it;       // Error: ambiguous
}

template<typename T>
class Container {
public:
    void func() {
        T::iterator it;     // Dependent name - could be type or value
        typename T::iterator it2;  // Disambiguated as type
        
        T::size();          // Dependent name - function call
        // No ambiguity here
    }
};

class MyClass {
public:
    typedef int iterator;
    static void size() {}
};

template<typename T>
void func(T param) {}

template<typename T>
void func2(T& param) {}

int main() {
    int x = 5;
    const int cx = 10;
    
    func(x);      // T = int
    func(cx);     // T = int (const is adjusted)
    func2(x);     // T = int
    // func2(cx);  // Error: can't bind const int& to int&
    
    return 0;
}

// In header file

template<typename T>
T multiply(T a, T b);

// In source file

template<typename T>
T multiply(T a, T b) { return a * b; }

// Explicit instantiations

template int multiply(int, int);
template double multiply(double, double);

int main() {
    int result = multiply(3, 4);  // Uses explicit instantiation
    return 0;
}

// Template template parameter example
// Allows templates to accept other templates as parameters

// Compile-time Fibonacci using template metaprogramming
// Templates generate code at compile-time for computation