Templates in C++

# CHAPTER 20

Templates in C++ #

1. Introduction #

2. Learning Objectives #

• Understand the concept of Generic Programming.

• Write Function Templates.

• Write Class Templates.

• Understand Template Specialization.

3. Generic Programming #

4. Function Templates #

Syntax: template <typename T>

#include <iostream>
using namespace std;

// 'T' acts as a placeholder for ANY data type (int, float, string, etc.)
template <typename T>
T myMax(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    // The compiler generates an int version of myMax
    cout << myMax<int>(10, 20) << endl; 
    
    // The compiler generates a float version of myMax
    cout << myMax<float>(3.14f, 5.99f) << endl; 
    
    // Modern C++ can often deduce the type automatically!
    cout << myMax(&#039;A&#039;, &#039;Z&#039;) << endl; 

    return 0;
}

5. Multiple Template Parameters #

template <typename T, typename U>
void printData(T data1, U data2) {
    cout << "Data 1: " << data1 << endl;
    cout << "Data 2: " << data2 << endl;
}

int main() {
    // T becomes string, U becomes int
    printData<string, int>("Score", 100); 
    return 0;
}

6. Class Templates #

template <typename T>
class Box {
  private:
    T content;
  public:
    void setContent(T newContent) {
        content = newContent;
    }
    T getContent() {
        return content;
    }
};

int main() {
    Box<int> intBox; // A Box that holds integers
    intBox.setContent(123);
    
    Box<string> stringBox; // A Box that holds strings
    stringBox.setContent("Secret Message");
    
    cout << intBox.getContent() << endl;
    cout << stringBox.getContent() << endl;

    return 0;
}

7. Template Specialization #

template <typename T>
void print(T data) {
    cout << "Generic: " << data << endl;
}

// Specialization for chars
template <>
void print<char>(char data) {
    cout << "Character specialized: " << data << endl;
}

int main() {
    print(100);   // Calls generic
    print(&#039;X&#039;);   // Calls specialized!
    return 0;
}

8. Memory-Level Explanation #

If you call myMax<int> and myMax<float>, the compiler writes the actual machine code for TWO separate functions behind the scenes. This is called Template Instantiation. This makes templates extremely fast (no runtime overhead), but it can increase the final .exe file size (Code Bloat).

9. Common Mistakes #

• Putting template definitions in .cpp files: Because the compiler needs to generate the code at the exact moment the template is called in main(), template *definitions* must usually be placed entirely in the .h header file.

• Forgetting <Type> in Class Templates: You cannot write Box b;. You MUST specify the type: Box<int> b;.

10. Exercises #

1. 1. Write a function template swapData that swaps two variables of any type. Test it with integers and strings.

1. 2. Write a class template Pair that holds two variables of the same generic type, with a method getLarger() that returns the larger of the two.

11. MCQ Quiz with Answers #

Q6. When instantiating a Class Template, must you specify the data type in angle brackets? a) Yes (e.g., Box<int>) b) No Answer: a) Yes (e.g., Box<int>)

12. Interview Questions #

• Q: Explain why template declarations and definitions are usually kept together in the header file.

• Q: What is the difference between Macros (#define) and Templates for generic programming? (Answer: Templates are type-safe and evaluated by the compiler; Macros are blind text-replacements evaluated by the preprocessor).

• Q: What is Template Metaprogramming?

13. Summary #

14. Next Chapter Recommendation #