C++ templates chapter 3(Class Templates)

• A class template is a class that is implemented with one or more type parameters left open.

• To use a class template, you pass the open types as template arguments. The class template is then instantiated (and compiled) for these types.

• For class templates, only those member functions that are called are instantiated.

• You can specialize class templates for certain types.

• You can partially specialize class templates for certain types.

• You can define default values for class template parameters. These may refer to previous template parameters.

 1 #include <vector>
 2 #include <stdexcept>
 3 using namespace std;
 4 
 5 template <typename T>
 6 class Stack
 7 {
 8 private:
 9     vector<T> elems;
10 
11 public:
12     void push(const T&);
13     void pop();
14     const T top();
15     const bool empty(){ return elems.empty(); }
16 };
17 
18 template <typename T>
19 void Stack<T>::push(const T& elem)
20 {
21     elems.push_back(elem);
22 }
23 
24 template <typename T>
25 void Stack<T>::pop()
26 {
27     if(elems.empty())
28     {
29         throw out_of_range("Stack<>::pop(): empty stack");
30     }
31     elems.pop_back();
32 }
33 
34 template<typename T>
35 const T Stack<T>::top()
36 {
37     if(elems.empty())
38     {
39         throw out_of_range("Stack<>::top(): empty stack");
40     }
41     return elems.back();
42 }

 1 #include <deque>
 2 #include <string>
 3 #include <stdexcept>
 4 #include "stack1.hpp"
 5 using namespace std;
 6 
 7 template<>
 8 class Stack<string>
 9 {
10 private:
11     deque<string> elems;
12 
13 public:
14     void push(const string&);
15     void pop();
16     cosnt string top();
17     const bool empty()
18     {
19         return elems.empty();
20     }
21 };
22 
23 void Stack<string>::push(const string& elem)
24 {
25     elems.push_back(elem);
26 }
27 
28 void Stack<string>::pop()
29 {
30     if(elems.empty())
31     {
32         throw out_of_range("Stack<string>::pop(): empty stack");
33     }
34     elems.pop_back();
35 }
36 
37 const string Stack<string>::top()
38 {
39     if(elems.empty())
40     {
41         throw out_of_range("Stack<string>::top(): empty stack");
42     }
43     return elems.back();
44 }

 1 #include <vector>
 2 #include <stdexcept>
 3 using namespace std;
 4 
 5 template<typename T, typename CONT = vector<T> >
 6 class Stack
 7 {
 8 private:
 9     CONT elems;
10 public:
11     void push(const T&);
12     void pop();
13     const T top();
14     const bool empty()
15     {
16         return elems.empty();
17     }
18 };
19 
20 template<typename T, typename CONT>
21 void Stack<T, CONT>::push(const T& elem)
22 {
23     elems.push_back(elem);
24 }
25 
26 template<typename T, typename CONT>
27 void Stack<T, CONT>::pop()
28 {
29     if(elems.empty())
30     {
31         throw out_of_range("Stack<>::pop(): empty stack");
32     }
33     elems.pop_back();
34 }
35 
36 template<typename T, typename CONT>
37 const T Stack<T, CONT>::top()
38 {
39     if(elems.empty())
40     {
41         throw out_of_range("Stack<>::top(): empty stack");
42     }
43     return elems.back();
44 }

 1 #include <iostream>
 2 #include <string>
 3 #include <deque>
 4 #include <cstdlib>
 5 //#include "stack1.hpp"
 6 #include "stack3.hpp"
 7 using namespace std;
 8 
 9 int main()
10 {
11     try
12     {
13         /*Stack<int> intStack;
14         Stack<string> stringStack;
15 
16         intStack.push(7);
17         cout << intStack.top() << endl;
18 
19         stringStack.push("hello");
20         cout << stringStack.top() << endl;*/
21         //stringStack.pop();
22         //stringStack.pop();
23 
24         Stack<int> intStack;
25         Stack<double, deque<double> > dblStack;
26 
27         intStack.push(7);
28         cout << intStack.top() << endl;
29         //intStack.pop();
30 
31         dblStack.push(42.42);
32         cout << dblStack.top() << endl;
33         //dblStack.pop();
34         //dblStack.pop();
35 
36         cin.get();
37 
38         return 0;
39     }
40     catch(const exception& ex)
41     {
42         cerr << "Exception: " << ex.what() << endl;
43         return EXIT_FAILURE;
44     } 
45 
46 
47 }