template class

来着：http://blog.csdn.net/nuoshueihe/article/details/8238553

template class with type parameter

[cpp] view plain copy print ?

1. #include <iostream>
2. #include <stdlib.h>
3. using namespace std;
4. const int SIZE = 10;
6. template <class T>class MyClass {
7. T a[SIZE];
8. public:
9. MyClass(void)
10. {
11. int i;
13. for(i=0; i<SIZE; i++)
14. a[i] = i;
15. }
16. T &operator[](int i);
17. };
19. template <class T> T &MyClass<T>::operator[](int i)
20. {
21. if(i<0 || i> SIZE-1)
22. {
23. cout << endl << "Index value of ";
24. cout << i << " is out of bounds." << endl;
25. }
26. return a[i];
27. }
29. int main(void)
30. {
31. MyClass<int> int_array;
32. MyClass<double> double_array;
33. int i;
35. cout << "Integer array: ";
36. for(i=0; i<SIZE; i++)
37. int_array[i] = i;
38. for(i=0; i<SIZE; i++)
39. cout << int_array[i] << " ";
40. cout << endl;
42. cout << "Double array: ";
43. cout.precision(2);
44. for(i=0; i<SIZE; i++)
45. double_array[i] = (double)i/3;
46. for(i=0; i<SIZE; i++)
47. cout << double_array[i] << " ";
48. cout << endl;
50. int_array[12] = 100; // Calls overloaded array operator
51. }

#include <iostream>
#include <stdlib.h>
using namespace std;
const int SIZE = 10;

template <class T> class MyClass {
   T a[SIZE];
 public:
   MyClass(void)
    {
      int i;

      for(i=0; i<SIZE; i++)
         a[i] = i;
    }
   T &operator[](int i);
};

template <class T> T &MyClass<T>::operator[](int i)
{
   if(i<0 || i> SIZE-1)
    {
      cout << endl << "Index value of ";
      cout << i << " is out of bounds." << endl;
    }
   return a[i];
}

int main(void)
{
   MyClass<int> int_array;
   MyClass<double> double_array;
   int i;

   cout << "Integer array: ";
   for(i=0; i<SIZE; i++)
      int_array[i] = i;
   for(i=0; i<SIZE; i++)
      cout << int_array[i] << " ";
   cout << endl;

   cout << "Double array: ";
   cout.precision(2);
   for(i=0; i<SIZE; i++)
      double_array[i] = (double)i/3;
   for(i=0; i<SIZE; i++)
      cout << double_array[i] << " ";
   cout << endl;

   int_array[12] = 100;                 // Calls overloaded array operator
}

template class with generic parameter

[cpp] view plain copy print ?

1. #include <iostream>
2. using namespace std;
3. template<class T>class Distance {
4. public:
5. Distance(T distance);
6. void show_distance(void) {
7. cout << "The distance is " << distance <<" miles\n";
8. };
9. private:
10. T distance;
11. };
13. template<class T>
14. Distance<T>::Distance(T distance) { Distance::distance = distance; };
16. int main(void)
17. {
18. Distance<int> short_distance(100);
19. Distance<long> long_distance(2000000L);
21. short_distance.show_distance();
22. long_distance.show_distance();
23. }

#include <iostream>
using namespace std;
template<class T> class Distance {
  public:
    Distance(T distance); 
    void show_distance(void) { 
       cout << "The distance is " << distance << " miles\n"; 
    };
  private:
    T distance;
};

template<class T>
Distance<T>::Distance(T distance) { Distance::distance = distance; };

int main(void)
{
    Distance<int> short_distance(100);
    Distance<long> long_distance(2000000L);

    short_distance.show_distance();
    long_distance.show_distance();
}

Demonstrate a very simple safe pointer class.

[cpp] view plain copy print ?

1. #include <iostream>
2. #include <string>
4. using namespace std;
6. // The exception type thrown by the safe pointer.
7. class bad_ptr {
8. public:
9. string msg;
11. bad_ptr(string str) { msg = str; }
12. };
14. // A class used to demonstrate the safe pointer.
15. class myclass {
16. public:
17. int alpha;
18. int beta;
19. myclass(int p, int q) { alpha = p; beta = q; }
20. };
22. template <class T>class safe_ptr {
23. T *ptr;
24. public:
25. safe_ptr() { ptr = 0; }
27. T *operator->() {
28. if(!ptr != 0) throw bad_ptr("Attempt to use -> on null pointer.");
29. else return ptr;
30. }
32. T &operator*() {
33. if(!ptr) throw bad_ptr("Attempt to dereference null pointer.");
34. else return *ptr;
35. }
37. operator T *() { return ptr; }
39. T *operator=(T *val) { ptr = val; return ptr; }
40. };
42. int main()
43. {
44. safe_ptr<int> intptr;
46. try {
47. *intptr = 23;
48. cout << "The value pointed to by intptr is: " << *intptr << endl;
49. } catch(bad_ptr bp) {
50. cout << bp.msg << endl;
51. }
53. intptr = new int;
55. try {
56. *intptr = 23;
57. cout << "The value pointed to by intpr is: " << *intptr <<"\n\n";
58. } catch(bad_ptr bp) {
59. cout << bp.msg << endl;
60. }
62. safe_ptr<myclass> mcptr;
64. try {
65. mcptr = new myclass(100, 200);
66. cout << "The values of alpha and beta for mcptr are: "
67. << mcptr->alpha << " and " << mcptr->beta << endl;
69. mcptr->alpha = 27;
70. cout << "New value for mcptr->alpha: " << mcptr->alpha << endl;
71. cout << "Same as (*mcptr).alpha: " << (*mcptr).alpha << endl;
73. mcptr->beta = 99;
74. cout << "New value for mcptr->beta: " << mcptr->beta <<"\n\n";
75. } catch(bad_ptr bp) {
76. cout << bp.msg << endl;
77. }
79. safe_ptr<myclass> mcptr2;
81. try {
82. mcptr2->alpha = 88;
83. } catch(bad_ptr bp) {
84. cout << bp.msg << endl;
85. }
87. delete intptr;
88. delete mcptr;
90. return 0;
91. }

#include <iostream>
#include <string>

using namespace std;

// The exception type thrown by the safe pointer.
class bad_ptr {
public:
  string msg;

  bad_ptr(string str) { msg = str; }
};

// A class used to demonstrate the safe pointer.
class myclass {
public:
  int alpha;
  int beta;
  myclass(int p, int q) { alpha = p; beta = q; }
};

template <class T> class safe_ptr {
  T *ptr;
public:
  safe_ptr() { ptr = 0; }

  T *operator->() {
    if(!ptr != 0) throw bad_ptr("Attempt to use -> on null pointer.");
    else return ptr;
  }

  T &operator*() {
    if(!ptr) throw bad_ptr("Attempt to dereference null pointer.");
    else return *ptr;
  }

  operator T *() { return ptr; }

  T *operator=(T *val) { ptr = val; return ptr; }
};

int main()
{
  safe_ptr<int> intptr;

  try {
    *intptr = 23;
    cout << "The value pointed to by intptr is: " << *intptr << endl;
  } catch(bad_ptr bp) {
    cout << bp.msg << endl;
  }

  intptr = new int;

  try {
    *intptr = 23;
    cout << "The value pointed to by intpr is: " << *intptr << "\n\n";
  } catch(bad_ptr bp) {
    cout << bp.msg << endl;
  }

  safe_ptr<myclass> mcptr;

  try {
    mcptr = new myclass(100, 200);
    cout << "The values of alpha and beta for mcptr are: "
         << mcptr->alpha << " and " << mcptr->beta << endl;

    mcptr->alpha = 27;
    cout << "New value for mcptr->alpha: " << mcptr->alpha << endl;
    cout << "Same as (*mcptr).alpha: " << (*mcptr).alpha << endl;

    mcptr->beta = 99;
    cout << "New value for mcptr->beta: " << mcptr->beta << "\n\n";
  } catch(bad_ptr bp) {
    cout << bp.msg << endl;
  }

  safe_ptr<myclass> mcptr2;

  try {
    mcptr2->alpha = 88;
  } catch(bad_ptr bp) {
    cout << bp.msg << endl;
  }

  delete intptr;
  delete mcptr;

  return 0;
}

template extending

[cpp] view plain copy print ?

1. template <typename T>
2. class SimpleTemplate
3. {
4. public:
5. SimpleTemplate(T &inObject);
7. const T& get();
8. void set(T& inObject);
10. protected:
11. T& mObject;
12. };
14. template <typename T>
15. SimpleTemplate<T>::SimpleTemplate(T &inObject) : mObject(inObject)
16. {
17. }
19. template <typename T>
20. const T& SimpleTemplate<T>::get()
21. {
22. return mObject;
23. }
25. template <typename T>
26. void SimpleTemplate<T>::set(T& inObject)
27. {
28. mObject = inObject;
29. }
31. #include <iostream>
32. #include <string>
34. using namespace std;
36. int main(int argc,char** argv)
37. {
38. int i = 7;
39. SimpleTemplate<int> intWrapper(i);
40. i = 2;
41. cout << "wrapper value is " << intWrapper.get() << endl;
43. string str = "test";
44. SimpleTemplate<string> stringWrapper(str);
45. str += "!";
46. cout << "wrapper value is " << stringWrapper.get() << endl;
47. }

template <typename T>
class SimpleTemplate
{
 public:
  SimpleTemplate(T &inObject);

  const T& get();
  void set(T& inObject);

 protected:
  T& mObject;
};

template <typename T>
SimpleTemplate<T>::SimpleTemplate(T &inObject) : mObject(inObject)
{
}

template <typename T>
const T& SimpleTemplate<T>::get()
{
  return mObject;
}

template <typename T>
void SimpleTemplate<T>::set(T& inObject)
{
  mObject = inObject;
}

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char** argv)
{
  int i = 7;
  SimpleTemplate<int> intWrapper(i);
  i = 2;
  cout << "wrapper value is " << intWrapper.get() << endl;

  string str = "test";
  SimpleTemplate<string> stringWrapper(str);
  str += "!";
  cout << "wrapper value is " << stringWrapper.get() << endl;
}

sequence template

[cpp] view plain copy print ?

1. #include <iostream>
2. using namespace std;
4. template <class T,int N>
5. class sequence {
6. T memblock [N];
7. public:
8. void setmember (int x, T value);
9. T getmember (int x);
10. };
12. template <class T,int N>
13. void sequence<T,N>::setmember (int x, T value) {
14. memblock[x]=value;
15. }
17. template <class T,int N>
18. T sequence<T,N>::getmember (int x) {
19. return memblock[x];
20. }
22. int main () {
23. sequence <int,5> myints;
24. sequence <double,5> myfloats;
25. myints.setmember (0,100);
26. myfloats.setmember (3,3.1416);
27. cout << myints.getmember(0) << '\n';
28. cout << myfloats.getmember(3) << '\n';
29. return 0;
30. }

#include <iostream>
using namespace std;

template <class T, int N>
class sequence {
    T memblock [N];
  public:
    void setmember (int x, T value);
    T getmember (int x);
};

template <class T, int N>
void sequence<T,N>::setmember (int x, T value) {
  memblock[x]=value;
}

template <class T, int N>
T sequence<T,N>::getmember (int x) {
  return memblock[x];
}

int main () {
  sequence <int,5> myints;
  sequence <double,5> myfloats;
  myints.setmember (0,100);
  myfloats.setmember (3,3.1416);
  cout << myints.getmember(0) << '\n';
  cout << myfloats.getmember(3) << '\n';
  return 0;
}
  

Template Version of Generic binary sorted Tree.

[cpp] view plain copy print ?

1. #include <iostream>
2. #include <string.h>
3. using namespace std;
5. //A generic binary sorted tree.
6. template <class T>class gen_tree; //forward decl
7. template <class T>
8. class bnode {
9. private:
10. friend class gen_tree<T>;
11. bnode<T>* left;
12. bnode<T>* right;
13. T data;
14. int count;
15. bnode(T d, bnode<T>* l, bnode<T>* r) :
16. data(d), left(l), right(r), count(1) { }
17. void print() const
18. { cout << data << " : " << count <<'\t'; }
19. };
21. template <class T>
22. class gen_tree {
23. public:
24. gen_tree() { root = 0; }
25. void insert(T d);
26. T find(T d) const { return (find(root, d)); }
27. void print() const { print(root); }
28. private:
29. bnode<T>* root;
30. T find(bnode<T>* r, T d) const;
31. void print(bnode<T>* r)const;
32. };
34. template <class T>
35. void gen_tree<T>::insert(T d)
36. {
37. bnode<T>* temp = root;
38. bnode<T>* old;
40. if (root == 0) {
41. root = new bnode<T>(d, 0, 0);
42. return;
43. }
44. while (temp != 0) {
45. old = temp;
46. if (comp(temp -> data, d) == 0) {
47. (temp -> count)++;
48. return;
49. }
50. if (comp(temp -> data, d) > 0)
51. temp = temp -> left;
52. else
53. temp = temp -> right;
54. }
55. if (comp(old -> data, d) > 0)
56. old -> left = new bnode<T>(d, 0, 0);
57. else
58. old -> right = new bnode<T>(d, 0, 0);
59. }
61. template <class T>
62. T gen_tree<T>::find(bnode<T>* r, T d) const
63. {
64. if (r == 0)
65. return 0;
66. else if (comp(r -> data, d) == 0)
67. return (r -> data);
68. else if (comp(r -> data, d) > 0)
69. return (find( r -> left, d));
70. else
71. return (find( r -> right, d));
72. }
74. template <class T>
75. void gen_tree<T>::print(bnode<T> *r)const
76. {
77. if (r != 0) {
78. print( r -> left);
79. r -> bnode<T>::print();
80. print ( r -> right);
81. }
82. }
84. template <class T>//general case
85. int comp(T i, T j)
86. {
87. if (i == j) //assumes == < defined for T
88. return 0;
89. else
90. return ( (i < j) ? -1 : 1 );
91. }
93. //specialization for const char*
94. int comp(constchar* i, constchar* j){
95. return (strcmp(i, j));
96. }
98. int main()
99. {
100. char dat[256];
101. gen_tree<char*> t;
102. char* p;
104. while (cin>>dat){
105. p = new char[strlen(dat) + 1];
106. strcpy(p, dat);
107. t.insert(p);
108. }
109. t.print();
110. cout << "EOF" << endl << endl;
112. gen_tree<int> i_tree;
114. for (int i = 15; i > -5; --i)
115. i_tree.insert(i);
116. i_tree.print();
117. }