The document describes C++ templates and how they can be used to define generic containers like Vector that work for different element types. It shows how to define a Vector class with a template parameter T for the element type. It also demonstrates how templates can be used to write algorithms that work on different container types by extracting the element type. Functions, classes, and type aliases can all be templated.

2. Templates
Variadic Templates
Aliases

3. 01. template <typename T>
02. class Vector {
03. private:
04. // elem points to an array of sz elements of type T
05. T* elem;
06. int sz;
07. public:
08. Vector(int s); // Constructor
09. ~Vector() { delete[] elem; } // Destructor
10.
11. // ... copy and move operations ...
12.
13. T& operator[](int i);
14. const T& operator[](int i) const;
15. int size() const { return sz; }
16. };

4. 01. template <typename T>
02. Vector<T>::Vector(int s)
03. {
04. if (s < 0) throw Negative_size();
05. elem = new T[s];
06. sz = s;
07. }
08.
09. template <typename T>
10. const T& Vector<T>::operator[](int i) const
11. {
12. if (i < 0 || size() <= i)
13. throw out_of_range("Vector::operator[]");
14. return elem[i];
15. }

5. 01. Vector<char> vc(200); // vector of 200 characters
02. Vector<string> vs(17); // vector of 17 strings
03. Vector<list<int>> vli(45); // vector of 45 lists of integers
01. void write(const Vector<string>& vs) // Vector of some strings
02. {
03. for (int i = 0; i!=vs.size(); ++i)
04. cout << vs[i] << 'n';
05. }

6. 01. template<typename T>
02. T* begin(Vector<T>& x)
03. {
04. // pointer to first element
05. return &x[0];
06. }
01. template<typename T>
02. T* end(Vector<T>& x)
03. {
04. // pointer to one-past-last element
05. return x.begin()+x.size();
06. }
01. void f2(const Vector<string>& vs) // Vector of some strings
02. {
03. for (auto& s : vs)
04. cout << s << 'n';
05. }

7. 01. template<typename Container, typename Value>
02. Value sum(const Container& c, Value v)
03. {
04. for (auto x : c)
05. v+=x;
06. return v;
07. }
01. void user(Vector<int>& vi, std::list<double>& ld,
02. std::vector<complex<double>>& vc)
03. {
04. int x = sum(vi,0);// the sum of a vector of ints (add ints)
05. double d = sum(vi,0.0);// the sum of a vector of ints (add doubles)
06. double dd = sum(ld,0.0);// the sum of a list of doubles
07. // the sum of a vector of complex<double> the initial value is {0.0,0.0}
08. auto z = sum(vc,complex<double>());
09. }

8. 01. template<typename T, typename... Tail>
02. void f(T head, Tail... tail)
03. {
04. g(head); // do something to head
05. f(tail...); // try again with tail
06. }
07.
08. void f() { } // do nothing
09.
10. int main()
11. {
12. cout << "first: ";
13. f(1,2.2,"hello");
14. cout << "nsecond: "
15. f(0.2,'c',"yuck!",0,1,2);
16. cout << "n";
17. }

9. 01. template<typename T>
02. void g(T x)
03. {
04. cout << x << " ";
05. }
first: 1 2.2 hello
second: 0.2 c yuck! 0 1 2

10. 01. template<typename T>
02. class Less_than {
03. const T val; // value to compare against
04. public:
05. Less_than(const T& v) :val(v) { }
06. // call operator
07. bool operator()(const T& x) const { return x<val; }
08. };
01. Less_than<int> lti {42}; // lti(i) will compare i to 42 using < (i<42)
02. // lts(s) will compare s to "Backus" using < (s<"Backus")
03. Less_than<string> lts {"Backus"};
04.
05. void fct(int n, const string & s)
06. {
07. bool b1 = lti(n); // true if n<42
08. bool b2 = lts(s); // true if s<"Backus"
09. // ...
10. }

11. 01. template<typename C, typename P>
02. int count(const C& c, P pred)
03. {
04. int cnt = 0;
05. for (const auto& x : c)
06. if (pred(x))
07. ++cnt;
08. return cnt;
09. }
01. void f(const Vector<int>& vec, const list<string>& lst, int x
02. , const string& s)
03. {
04. cout << "number of values less than " << x
05. << ": " << count(vec,Less_than<int>{x}) << 'n';
06. cout << "number of values less than " << s
07. << ": " << count(lst,[&](const string& a){ return a<s; })
08. << 'n';
09. }

12. 01. typedef unsigned int size_t;
02.
03. using size_t = unsigned int;
04.
05. template<typename T>
06. class Vector {
07. public:
08. using value_type = T;
09. // ...
10. };

13. 01. template<typename C>
02. using Element_type = typename C::value_type;
03.
04. template<typename Container>
05. void algo(Container& c)
06. {
07. Vector<Element_type<Container>> vec; // keep results here
08. // ...
09. }
01. template<typename Key, typename Value>
02. class Map {
03. // ...
04. };
05.
06. template<typename Value>
07. using String_map = Map<string,Value>;
08.
09. String_map<int> m; // m is a Map<string,int>