17. Generic Programming and Templates

In Python, we could easily write functions that dealt with a variety of different input types without knowing those exact types as we wrote our code.

//filename: script0.py
//execute: python script0.py
def min(a,b):
    if (a < b):
        return a
    else:
        return b

print(min(5, 3))
print(min(2.72, 3.14))
print(min("world","hello"))

With C++’s static typing, we need to explicitly define those types.

The idea behind generic programming is to have templated functions and classes in which the logic is written independently of any particular type. As we use templated code, we then supply the appropriate types and the compiler instantiates functions and/or classes specific to the specified type(s). Effectively, these templates serve as blueprints and we still have the advantage of well-defined types.

17.1. Templated Functions

In the following code, we define a templated function min that works for a variety of different types as long as that type (class) implements the < operator.

In this example, we declare a placeholder for the type name immediately before the function definition: template <typename t>

template<typename T>
returnType functionName(parameterList){
    //function body
}

T can be any type. We can use other placeholder names than T and have multiple “substitution” types (just separate by commas)

If the compiler can determine the type(s) for the templated function, we do not need to explicitly state the type (line 16). However, in the case of line 17 as the two arguments differ in type, we need explicitly tell the compiler which type to using within the myMin function.

//filename: min_template.cpp
//complile: g++ -std=c++17 -o min_template min_template.cpp
//execute: ./min_template
#include <iostream>
#include <string>
using namespace std;

template <typename T>
T myMin(T a, T b) {
    if (a < b) {
        return a;
    }
    else {
        return b;
    }
}

int main(int argc, char *argv[]) {
    cout << myMin(1.0,0.5) << endl;
    cout << myMin<int>(42, 37.4) << endl;

    // use the C++ string class
    string s1("Jane");
    string s2("John");
    cout << myMin(s1, s2) << endl;

    return EXIT_SUCCESS;
}

17.2. Templated Classes

Templated classes operate much the same way templated functions do. We specify the type substitutions ahead of the class definition instead of the function defintion.

template<typename T>
class ClassName {
private:
    //private members
public:
    //public members
}

As the entire class must be available for the compiler to instantiate a new class definition where the templated classes are instantiated, the entire body of the class is typically defined in header files.

//filename: point.hpp
//complile: g++ -std=c++17 -o point point.hpp
//execute: ./point
#include <string>
#include <cmath>
using std::string;

#ifndef POINT_TEMPLATE_H_
#define POINT_TEMPLATE_H_

template <typename T>
class Point {
private:
    T x;
    T y;

public:
    Point(T initialX, T initialY) : x{initialX}, y{initialY} {}

    T getX() const {
        return x;
    }

    void setX(T val) {
        x = val;
    }

    T getY() const{
        return this->y;
    }

    void setY(T val) {
        this->y = val;
    }

    T distance(Point other) const {
        T dx = x - other.x;
        T dy = y - other.y;
        return sqrt(dx * dx + dy *dy);
}

    string toString() {
        return "("+std::to_string(x)+","+std::to_string(y)+")";
    }
};

#endif

The follow main method demonstrates using the templated Point class.

//filename: testPoint.cpp
//complile: g++ -std=c++17 -o testPoint testPoint.cpp
//execute: ./testPoint
#include "point.hpp"
#include <iostream>
#include <string>

int main(int argc, char *argv[]) {
    Point<double> dp(1.0,3.14);
    std::cout << dp.toString() << std::endl;

    Point<int> ip(1,5);
    std::cout << ip.toString() << std::endl;

    Point<char> cp('A','D');
    std::cout << cp.toString() << std::endl;

    Point<int> p(10,3);
    std::cout << ip.distance(p) << std::endl;

}

Notes:

• Templated classes and functions are only type-checked once they are instantiated by the compiler. If the underlying type does not support operators or other function arguments than a compilation error will occur.

• With functions, template parameters may be inferred. However, with classes, the template parameters must always be supplied. e.g., Point x(1,2) produces a compilation error.

• Note: instead of template<typename T>, template<class T> can be used. The two statements have the same semantic meaning. While Bjarne Stroustrup states in Programming: Principles and Practices Using C++, “We are of the opinion that class already means type, so it makes no difference. Also, class is shorter.”, this statement leaves much to be desired. In C++, class actually means a user-defined type and is separate from the primitive types. Prefer the keyword typename to avoid confusion.