Class Templates — Generic Containers

Writing a class template

The template<typename T> prefix appears before the class definition, not before each member. When defining member functions outside the class body, each definition must also be prefixed with the template header and the class name must be written as ClassName<T>.

template<typename T>
class Stack {
public:
    void push(const T& value) { data_.push_back(value); }
    void push(T&& value)      { data_.push_back(std::move(value)); }
    void pop()                { data_.pop_back(); }
    const T& top() const      { return data_.back(); }
    bool empty() const        { return data_.empty(); }
    std::size_t size() const  { return data_.size(); }
private:
    std::vector<T> data_;
};

// Instantiation — compiler generates Stack<int> and Stack<std::string>:
Stack<int> ints;
ints.push(1); ints.push(2); ints.push(3);
std::cout << ints.top();   // 3

Stack<std::string> words;
words.push("hello"); words.push("world");
std::cout << words.top();  // world

Member functions are only instantiated when they are actually called — not when the class is instantiated. This means a class template can have member functions that use operations not supported by all types, as long as those functions are not called with those types.

Defining member functions outside the class

For longer member functions it is cleaner to define them after the class body. Each out-of-class definition must repeat the template header and use ClassName<T>:: as the scope prefix.

template<typename T>
class Pair {
public:
    Pair(T first, T second);
    T min() const;
    T max() const;
private:
    T first_, second_;
};

// Out-of-class definitions — each needs its own template header:
template<typename T>
Pair<T>::Pair(T first, T second) : first_(first), second_(second) {}

template<typename T>
T Pair<T>::min() const {
    return (first_ < second_) ? first_ : second_;
}

template<typename T>
T Pair<T>::max() const {
    return (first_ > second_) ? first_ : second_;
}

Pair<int> p{3, 7};
std::cout << p.min();  // 3
std::cout << p.max();  // 7

Default template arguments

Template parameters can have default arguments, just like function parameters. This is how std::vector<T, Allocator> works: the allocator defaults to std::allocator<T>so most users only write std::vector<int>.

template<typename T, typename Container = std::vector<T>>
class Stack {
public:
    void push(const T& v) { c_.push_back(v); }
    void pop()            { c_.pop_back(); }
    const T& top() const  { return c_.back(); }
    bool empty() const    { return c_.empty(); }
private:
    Container c_;
};

Stack<int>                s1;   // uses vector<int>
Stack<int, std::deque<int>> s2; // uses deque<int>

Class Template Argument Deduction (C++17)

Before C++17, class template arguments could not be deduced from constructor arguments — you had to write the type explicitly. C++17's Class Template Argument Deduction (CTAD) allows the compiler to deduce template arguments from constructor arguments, similar to function template deduction.

// Pre-C++17: must specify type explicitly
std::pair<int, std::string> p1(42, "hello");
std::vector<int> v1 = {1, 2, 3};

// C++17 CTAD: type deduced from constructor arguments
auto p2 = std::pair(42, "hello");    // pair<int, const char*>
auto v2 = std::vector{1, 2, 3};     // vector<int>

// Works with your own templates too:
template<typename T>
class Wrapper { public: Wrapper(T v) : val_(v) {} private: T val_; };

auto w = Wrapper(42);    // C++17: T deduced as int, no need to write Wrapper<int>
auto s = Wrapper{std::string("hi")};  // T = std::string

Key rules to remember