XQA
Back to C++
2025-12-306 min read

C++ Templates

Learn C++ Templates step by step with clear examples and exercises.

Why This Matters

Welcome to this full guide on C++ Templates! This tutorial is designed to help you understand the power and practicality of using templates in your C++ programming journey, going beyond what you'll find on Programiz, GeeksforGeeks, or TutorialsPoint.

Templates are a key feature in modern C++ programming that allow you to write generic code that can work with various data types. They enable reusability and flexibility, saving you time and effort when dealing with different data structures. Templates can be particularly useful for creating libraries or writing efficient code for competitive programming and real-world applications.

By mastering C++ templates, you'll be able to write more versatile and adaptable code that can handle a wide range of data types without the need for multiple function implementations or manual type conversions. This will make your code cleaner, easier to maintain, and more efficient.

Prerequisites

To fully grasp the concepts in this tutorial, you should have a good understanding of:

  1. Basic C++ syntax, including variables, functions, loops, and control structures.
  2. Understanding of classes and objects in C++.
  3. Familiarity with STL (Standard Template Library) containers like vector, list, and map.
  4. A solid grasp of C++ object-oriented programming concepts such as inheritance, polymorphism, and encapsulation.

Core Concept

Definition and Instantiation

A template is a piece of code that can be reused for different data types. It contains placeholders for the actual data type, which are replaced during compilation to generate specific instances (also called instantiations) of the template.

Here's a simple example of a template function:

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

In this example, T is a placeholder for any data type. When we instantiate the function with a specific data type, the placeholder is replaced, and the resulting code can be compiled and executed. For instance:

printValue(42); // prints "42"
printValue(3.14); // prints "3.14"

Template Classes

Templates can also be used to create generic classes. Here's an example of a simple template class for a stack:

template <typename T>
class Stack {
public:
void push(const T& value) {
// Implementation for pushing a value onto the stack
}

T pop() {
// Implementation for popping a value from the stack
}

private:
std::vector<T> elements;
};

In this example, the class Stack can be instantiated with any data type that supports copy construction (e.g., built-in types, strings, or custom classes).

Template Specialization

Template specialization allows you to provide a specific implementation for a particular data type or set of data types. This can be useful when the default template implementation doesn't meet your requirements for certain data types.

template <typename T>
class Stack {
public:
// Default implementation...
};

// Specialization for std::string
template <>
class Stack<std::string> {
public:
void push(const std::string& value) {
// Implementation for pushing a string onto the stack (e.g., using a different container like std::list)
}

std::string pop() {
// Implementation for popping a string from the stack
}
};

Worked Example

Let's create a template function to find the maximum value in an array of integers and doubles:

template <typename T>
T findMax(const std::vector<T>& values) {
if (values.empty()) {
throw std::runtime_error("Empty vector");
}

T max = values[0];
for (size_t i = 1; i < values.size(); ++i) {
if (values[i] > max) {
max = values[i];
}
}

return max;
}

Now, we can use this function with both integers and doubles:

int intValues[] = {4, 2, 9, 6};
double doubleValues[] = {1.5, 3.7, 8.2, 0.1};

std::vector<int> intVector(intValues, intValues + sizeof(intValues) / sizeof(int));
std::vector<double> doubleVector(doubleValues, doubleValues + sizeof(doubleValues) / sizeof(double));

std::cout << "Max integer: " << findMax<int>(intVector) << std::endl;
std::cout << "Max double: " << findMax<double>(doubleVector) << std::endl;

Common Mistakes

  1. Template arguments must be types, not variables or expressions. You cannot use a variable or expression as a template argument. For example, the following code will result in a compilation error:
int a = 5;
printValue<a>(42); // Error!
  1. Incomplete types are not allowed as template arguments. If you try to use an incomplete type (e.g., a class that has not been fully defined) as a template argument, the compiler will generate an error:
struct Foo { /* ... */ }; // Incomplete definition

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

Foo foo;
printValue<Foo>(foo); // Error!
  1. Ambiguity in derived classes. When using templates with derived classes, the compiler may face ambiguity issues if multiple base classes have member functions with the same name and signature. To resolve this issue, you can use using declarations or qualified names (i.e., base_class::member_function) to disambiguate the member function.
  1. Template argument deduction. When instantiating a template function without explicit type arguments, the compiler attempts to deduce the template arguments from the provided arguments. However, this can sometimes lead to unexpected results or errors if the types are not correctly inferred. To avoid such issues, it's recommended to explicitly specify the template arguments when calling functions or constructing objects.

Practice Questions

  1. Write a template function that swaps two elements in an array of any data type.
  2. Create a template class for a queue that supports pushing and popping elements of any data type.
  3. Implement a template function to find the second-largest value in a vector of integers.
  4. Discuss the differences between template specialization and overloading.
  5. Explain how to use templates to create a generic implementation of STL containers like vector or map.
  6. What is SFINAE (Substitution Failure Is Not An Error), and why is it important in C++ templates? Provide an example demonstrating its usage.
  7. How can you write a template function that works with both built-in types and custom classes, but performs differently based on the type of the argument?
  8. Discuss the pros and cons of using templates in C++ programming.
  9. What are some common pitfalls to avoid when working with templates in C++?
  10. How can you write a template function that works with both value types (e.g., int, double) and pointer types (e.g., int, double)?

FAQ

  1. Can I use templates with built-in types like int or double? Yes, you can use templates with built-in types as well as custom classes and user-defined types.
  2. What happens if I try to instantiate a template function with an incorrect data type? If you attempt to instantiate a template function with an incorrect data type, the compiler will generate an error during compilation.
  3. Can I use templates to create a generic implementation of STL containers like vector or map? While it's possible to create your own generic container classes using templates, it's generally recommended to use the built-in STL containers whenever possible due to their efficiency and extensive optimizations.
  4. What is SFINAE (Substitution Failure Is Not An Error), and why is it important in C++ templates? SFINAE is a technique used in C++ templates that allows for the compilation of template code even when some template arguments fail to compile. This enables more flexible and robust template designs by allowing the compiler to skip over errors during template instantiation.
  5. How can I write a template function that works with both value types (e.g., int, double) and pointer types (e.g., int, double)? To write a template function that works with both value types and pointer types, you can use std::remove_pointer or std::remove_reference to remove the pointer or reference qualifiers from the template argument. This allows the function to work with both pointers and values.
  6. What are some common pitfalls to avoid when working with templates in C++? Some common pitfalls include:
  • Incorrect template argument deduction leading to unexpected behavior or errors.
  • Ambiguity issues when using templates with derived classes.
  • Using variables or expressions as template arguments instead of types.
  • Incomplete types as template arguments.
  • Overusing templates, which can lead to complex and difficult-to-maintain code.
  1. How can I write a template function that performs differently based on the type of the argument? To write a template function that performs differently based on the type of the argument, you can use conditional compilation (e.g., if constexpr) or type traits (e.g., std::is_integral, std::is_floating_point) to check the type at compile time and provide different implementations accordingly.
C++ Templates | C++ | XQA Learn