C++ generic programming is a powerful programming paradigm that allows you to write code that is independent of specific data types, thereby enhancing code reusability and flexibility.
What is Generic Programming?
The core idea of generic programming is “write once, use many times”. It enables functions or classes to handle multiple data types without the need to rewrite code for each type.
Main Implementations of C++ Generic Programming
1. Function Templates
Function templates allow you to create a generic function that can operate on various data types.Basic Syntax:
template <typename T> // or use class keyword instead of typenamereturn type function name(parameter list) { // function body, using type T}Example: Implementing a generic swap function
template <typename T>void swap(T& a, T& b) { T temp = a; a = b; b = temp;}// Usage exampleint main() { int x = 5, y = 10; swap(x, y); // T is automatically deduced as int double a = 3.14, b = 2.71; swap(a, b); // T is automatically deduced as double return 0;}2. Class Templates
Class templates are used to create classes that can handle multiple data types, with the most typical examples being containers in the C++ Standard Library (such as<span>vector</span>, <span>list</span>, etc.).Basic Syntax:
template <typename T>class ClassName { // class members, using type T};Example: Implementing a simple stack template
template <typename T>class Stack {private: T* elements; int top; int capacity;public: Stack(int size) : capacity(size), top(-1) { // initialize size elements = new T[capacity]; } ~Stack() { delete[] elements; } void push(T value) { // push to stack if (top < capacity - 1) { elements[++top] = value; } } T pop() { // pop from stack if (top >= 0) { return elements[top--]; } }};3. Without Generic Programming
In C++, function overloading can be used to implement multiple versions of a function, such as swapping two numbers.
In C, macros can be used.
4. Template Parameters
Templates can have multiple parameters and can also have default parameters:
// Multiple template parameterstemplate <typename T, typename U>class Pair {private: T first; U second;public: Pair(T f, U s) : first(f), second(s) {}};// Template with default parameterstemplate <typename T = int>class Container { // implementation...};Generic Programming in the Standard Library
The C++ Standard Template Library (STL) is a paradigm of generic programming, mainly consisting of:
- Containers: such as
<span>vector<T></span>,<span>list<T></span>,<span>map<K, V></span>, etc. - Algorithms: such as
<span>sort()</span>,<span>find()</span>,<span>copy()</span>, etc. - Iterators: Bridges connecting containers and algorithms
Example: Using STL’s generic algorithms
#include <vector>#include <algorithm>#include <iostream>int main() { std::vector<int> numbers = {5, 2, 8, 1, 9}; // Using generic sorting algorithm std::sort(numbers.begin(), numbers.end()); // Using generic searching algorithm auto it = std::find(numbers.begin(), numbers.end(), 8); if (it != numbers.end()) { std::cout << "Found element: " << *it << std::endl; } return 0;}Advantages of Generic Programming
- Code Reusability One piece of code can handle multiple data types
- Type Safety Type checking at compile time
- Efficiency Compared to generic code using void *, code generated from templates is more efficient
- Flexibility Custom implementations can be provided for specific types
Considerations
- Template definitions usually need to be placed in header files
- Overusing templates may lead to code bloat and increased compilation time
Generic programming is a very important feature in C++. Mastering it can help you write more flexible, efficient, and maintainable code. The Standard Template Library (STL) is the best practice of generic programming, and a deep understanding of STL can better grasp the ideas of generic programming.