Explore the power of C++ templates and generic programming to create flexible and reusable code. Learn about function templates, class templates, template specialization, and the Standard Template Library (STL).
In C++, templates and generic programming are powerful tools that allow developers to write flexible, reusable, and type-safe code. By abstracting operations over types, templates enable us to define functions and classes that work with any data type. This section will delve into the intricacies of function templates, class templates, template specialization, and the Standard Template Library (STL), providing you with the knowledge to harness these features effectively.
Function templates are a cornerstone of generic programming in C++. They allow you to write a single function that can operate on different data types. Let’s explore how function templates work and how they can be implemented in C++.
A function template is defined using the template keyword followed by a template parameter list enclosed in angle brackets. Here’s a simple example:
1#include <iostream>
2
3// Define a function template
4template <typename T>
5T add(T a, T b) {
6 return a + b;
7}
8
9int main() {
10 std::cout << "Sum of integers: " << add(3, 4) << std::endl; // Calls add<int>
11 std::cout << "Sum of doubles: " << add(3.5, 4.5) << std::endl; // Calls add<double>
12 return 0;
13}
In this example, the add function template can add two numbers of any type. The compiler generates specific versions of the function for each type used in the program.
add<int>(3, 4);.template <typename T, typename U>.Experiment with the add function template by adding support for custom types. Define a simple Point struct and overload the + operator to see how the template handles user-defined types.
Class templates extend the concept of templates to classes, allowing you to create generic data structures and classes. This section will guide you through the process of defining and using class templates.
A class template is defined similarly to a function template, but it applies to an entire class. Here’s an example of a simple stack class template:
1#include <iostream>
2#include <vector>
3
4// Define a class template
5template <typename T>
6class Stack {
7private:
8 std::vector<T> elements;
9
10public:
11 void push(const T& element) {
12 elements.push_back(element);
13 }
14
15 void pop() {
16 if (!elements.empty()) {
17 elements.pop_back();
18 }
19 }
20
21 T top() const {
22 if (!elements.empty()) {
23 return elements.back();
24 }
25 throw std::out_of_range("Stack<>::top(): empty stack");
26 }
27
28 bool empty() const {
29 return elements.empty();
30 }
31};
32
33int main() {
34 Stack<int> intStack;
35 intStack.push(1);
36 intStack.push(2);
37 std::cout << "Top of intStack: " << intStack.top() << std::endl;
38
39 Stack<std::string> stringStack;
40 stringStack.push("Hello");
41 stringStack.push("World");
42 std::cout << "Top of stringStack: " << stringStack.top() << std::endl;
43
44 return 0;
45}
In this example, the Stack class template can store elements of any type. The type is specified when creating an instance of the class.
Modify the Stack class template to include a size method that returns the number of elements in the stack. Test it with different data types to ensure it works as expected.
Template specialization allows you to define specific implementations of a template for particular types. This is useful when you need to handle certain types differently.
Full specialization involves providing a complete implementation of a template for a specific type. Here’s an example:
1#include <iostream>
2
3// Primary template
4template <typename T>
5class Printer {
6public:
7 void print(const T& value) {
8 std::cout << "Value: " << value << std::endl;
9 }
10};
11
12// Full specialization for char*
13template <>
14class Printer<char*> {
15public:
16 void print(const char* value) {
17 std::cout << "String: " << value << std::endl;
18 }
19};
20
21int main() {
22 Printer<int> intPrinter;
23 intPrinter.print(42);
24
25 Printer<char*> stringPrinter;
26 stringPrinter.print("Hello, World!");
27
28 return 0;
29}
In this example, the Printer class template has a full specialization for char*, which handles strings differently from other types.
Partial specialization allows you to specialize a template for a subset of its parameters. Here’s an example with a class template:
1#include <iostream>
2
3// Primary template
4template <typename T, typename U>
5class Pair {
6public:
7 void display() {
8 std::cout << "Generic Pair" << std::endl;
9 }
10};
11
12// Partial specialization for pairs with the same type
13template <typename T>
14class Pair<T, T> {
15public:
16 void display() {
17 std::cout << "Specialized Pair" << std::endl;
18 }
19};
20
21int main() {
22 Pair<int, double> genericPair;
23 genericPair.display(); // Outputs: Generic Pair
24
25 Pair<int, int> specializedPair;
26 specializedPair.display(); // Outputs: Specialized Pair
27
28 return 0;
29}
In this example, the Pair class template has a partial specialization for pairs where both types are the same.
Create a class template for a Matrix and provide a specialization for Matrix<bool> that uses a more memory-efficient representation.
The Standard Template Library (STL) is a powerful library that provides a set of common data structures and algorithms. It heavily relies on templates to offer generic and reusable components.
The STL consists of several components, including:
vector, list, map, and set that store collections of objects.STL containers are versatile and can store any data type. Here’s an example using a vector:
1#include <iostream>
2#include <vector>
3#include <algorithm>
4
5int main() {
6 std::vector<int> numbers = {1, 2, 3, 4, 5};
7
8 // Use an STL algorithm to reverse the vector
9 std::reverse(numbers.begin(), numbers.end());
10
11 // Print the reversed vector
12 for (int num : numbers) {
13 std::cout << num << " ";
14 }
15 std::cout << std::endl;
16
17 return 0;
18}
In this example, the vector container stores integers, and the reverse algorithm reverses the order of the elements.
Experiment with different STL containers and algorithms. For example, use a map to count the frequency of words in a text and sort them by frequency.
To better understand the relationships between templates, specialization, and the STL, let’s visualize these concepts using a class diagram.
classDiagram
class FunctionTemplate {
+add(T a, T b)
}
class ClassTemplate {
+Stack~T~()
+push(T element)
+pop()
+top() T
+empty() bool
}
class TemplateSpecialization {
+Printer~T~()
+print(T value)
}
class STL {
+vector~T~()
+map~K, V~()
+reverse()
}
FunctionTemplate --> ClassTemplate : uses
ClassTemplate --> TemplateSpecialization : specializes
TemplateSpecialization --> STL : implements
add.Stack.Printer<char*>.vector and map.For further reading on templates and generic programming in C++, consider exploring the following resources:
Before moving on, let’s review some key concepts:
Remember, mastering templates and generic programming in C++ is a journey. As you continue to experiment and explore, you’ll discover new ways to leverage these powerful features to write more efficient and reusable code. Keep experimenting, stay curious, and enjoy the journey!