Home | Projects | Notes > C++ Programming > Generic Programming & Templates

Generic Programming & Templates

Overview

Generic programming / Meta-programming
- Preprocessor macros
- Function templates
- Class templates

Generic Programming with Macros

Generic programming
"Writing code that works with a variety of types as arguments, as long as those argument types meet specific syntactic and semantic requirements." - Bjarne Stroustrup
Macros - BEWARE!
Function templates
Class templates

Macros (`#define`)

C++ preprocessor directives
No type information
Simple substitution

Example of macros

Source file (.cpp)


xxxxxxxxxx
7
1
#define MAX_SIZE    100
2
#define PI          3.14159
3

4
if (num > MAX_SIZE)
5
    std::cout << "Too big";
6

7
double area = PI * r * r;

Expanded source file (.i)


xxxxxxxxxx
7
1
#define MAX_SIZE    100         // Removed
2
#define PI          3.14159     // Removed
3

4
if (num > 100)
5
    std::cout << "Too big";
6

7
double area = 3.14159 * r * r;

All macros will be expanded by the preprocessor. (Textual substitution)

Making code more generic by using macro with arguments instead of multiple functions


xxxxxxxxxx
5
1
#define MAX(a, b) ((a > b) ? a : b)
2

3
std::cout << MAX(10, 20)    << std::endl;   // 20
4
std::cout << MAX(2.4, 3.5)  << std::endl;   // 3.5
5
std::cout << MAX('A', 'C')  << std::endl;   // C

Instead of


xxxxxxxxxx
3
1
int max(int a, int b) { return (a > b) ? a : b; }
2
double max(double a, double b) { return (a > b) ? a : b; }
3
char max(char a, char b) { return (a > b) ? a : b; }

Caution! Use parenthesis generously!


xxxxxxxxxx
7
1
#define SQUARE(a)   a * a
2

3
result = SQUARE(5);     // Expect 25
4
result = 5 * 5;         // Get 25
5

6
result = 100 / SQUARE(5);   // Expect 4
7
result = 100 / 5 * 5;       // Get 100

Instead, guard each argument with parenthesis


xxxxxxxxxx
7
1
#define SQUARE(a)   ((a) * (a))
2

3
result = SQUARE(5);         // Expect 25
4
result = ((5) * (5));       // Still get 25
5

6
result = 100 / SQUARE(5);   // Expect 4
7
result = 100 / ((5) * (5)); // Now we get 4

Generic Programming with Function Templates

What is a C++ Template?
- Blueprint
- Function and class templates
- Allow plugging-in any data type
- Compiler generates the appropriate function/class from the blue print
- Generic programming / meta-programming

Example

Revisiting the previous example, we can replace the type we want to generalize with a name, say T. But, now this won't compile.


xxxxxxxxxx
1
1
T max(T a, T b) { return (a > b) ? a : b; }

We need to tell the compiler that this is a template function, and that T is the template parameter.


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

Can use class instead of typename


xxxxxxxxxx
2
1
template <class T>
2
T max(T a, T b) { return (a > b) ? a : b; }

Now the compiler can generate the appropriate function from the template.

Note, this happens at compile-time.


xxxxxxxxxx
4
1
int a{10};
2
int b{20};
3

4
std::cout << max<int>(a, b);

Many times the compiler can deduce the type and the template parameter is not needed. Depending on the type of a and b, the compiler will figure it out.


xxxxxxxxxx
2
1
std::cout << max<double>(c, d);
2
std::cout << max(c, d);

And we can use almost any type we need.


xxxxxxxxxx
4
1
char a{'A'};
2
char b{'B'};
3

4
std::cout << max(a, b) << std::endl;

Notice that the type MUST support the > operator either natively or as an overloaded operator (operator>).


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

The following will not compile unless Player overloads operator>.


xxxxxxxxxx
4
1
Player p1{"Hero", 100, 20};
2
Player p2{"Enemy", 99, 3};
3

4
std::cout << max<Player>(p1, p2);

Templates can have multiple parameters, and their types can be different.


xxxxxxxxxx
2
1
template <typename T1, typename T2>
2
void func(T1 a, T2 b) { std::cout << a << " " << b; }

When we use the function we provide the template parameters. often the compiler can deduce them.