C++第十二天笔记2016年03月04日（周五） A.M

1.    多重继承

在多继承中，如果派生类的多个基类出现重名函数，为了避免出现歧义，则可以在派生类中重写这些重名函数。

2.    菱形继承问题，成员冗余（成员变量的冗余，无问题。成员函数的冗余，可能会出现问题）。函数调用出现歧义。

使用虚继承解决菱形继承问题。

3.    模板

函数模板：有类型参数的函数。

如何定义函数模板：

1 template <typename T>
2 void print(T,_t)
3 {
4        cout<< _t << endl;
5 }
6 print(1);
7 print(“hello”);
8 print(&a);

模板函数：类型参数的值确定。void print(T,_t);

4. 普通函数和函数模板的区别：

普通函数：参数值未定，但参数类型确定。

函数模板：不仅参数的值不确定，连参数的类型都不确定，我们使用template来创建模板关键字这是一种 更高级的 复用。

5.  课堂练习

1. 函数模板：

 1 #include <iostream>
 2 using namespace std;
 3
 4
 5 //void printArray(int* array, int size)
 6 //{
 7 //    for (int i=0; i< size; i++) {
 8 //        cout << array[i];
 9 //        if (i<(size-1)) {
10 //            cout << ", ";
11 //        }
12 //    }
13 //    cout<<endl;
14 //}
15 //
16 //void printArray(float* array, int size)
17 //{
18 //    for (int i=0; i< size; i++) {
19 //        cout << array[i];
20 //        if (i<(size-1)) {
21 //            cout << ", ";
22 //        }
23 //    }
24 //    cout<<endl;
25 //}
26 //void printArray(char** array, int size)
27 //{
28 //    for (int i=0; i< size; i++) {
29 //        cout << array[i];
30 //        if (i<(size-1)) {
31 //            cout << ", ";
32 //        }
33 //    }
34 //    cout<<endl;
35 //}
36
37 template <typename T>
38 void printArray(T* array,int size)
39 {
40     for (int i=0; i<size; i++) {
41         cout << array[i];
42
43         if (i<(size-1)) {
44             cout << ", ";
45         }
46     }
47     cout << endl;
48 }
49
50 int main(int argc, const char * argv[]) {
51
52     const int max = 5;
53     int iarray[max] = {3,4,5,6,7};
54     float farray[max] = {2.1, 2.2, 2.3, 2.4, 2.5};
55     char* cArray[max] = {"df", "fvc" , "zdf", "ht", "dsfa"};
56
57     printArray(iarray, max);
58     printArray(farray, 5);
59     printArray(cArray, 5);
60
61     return 0;
62 }

2. 类模板

  1 #include <iostream>
  2 using namespace std;
  3
  4 template <typename T>
  5 class Stack
  6 {
  7 private:
  8     int size;
  9     int top;
 10     T* stackPtr;
 11
 12 public:
 13     Stack(int s = 10);
 14     ~Stack();
 15
 16     int push(const T&);
 17     int pop(T&);
 18     int isEmpty() const;
 19     int isFull() const;
 20
 21     void printOn(ostream& output);
 22 };
 23
 24 template <typename T>
 25 Stack<T>::~Stack(){
 26     if (stackPtr != NULL) {
 27         delete [] stackPtr;
 28         stackPtr = NULL;
 29     }
 30 }
 31
 32 template <typename T>
 33 Stack<T>::Stack(int s){
 34     size = s;
 35     top=-1;
 36     stackPtr = new T[size];
 37 }
 38
 39 template <typename T>
 40 int Stack<T>::push(const T& item){
 41     if (!isFull()) {
 42         stackPtr[++top] = item;
 43         return 1;
 44     }
 45     return 0;
 46 }
 47
 48 template <typename T>
 49 int Stack<T>::pop(T& item){
 50     if (!isEmpty()) {
 51         item = stackPtr[top--];
 52         return 1;
 53     }
 54     return 0;
 55 }
 56
 57 template <typename T>
 58 int Stack<T>::isEmpty() const{
 59     return top == -1;
 60 }
 61
 62 template <typename T>
 63 int Stack<T>::isFull() const{
 64     return top == size-1;
 65 }
 66
 67
 68 template <typename T>
 69 void Stack<T>::printOn(ostream& output){
 70     output << "Stack( ";
 71     for (int i = 0; i <= top; i++) {
 72         output << stackPtr[i];
 73         if (i<top)
 74         {
 75             cout<<", ";
 76         }
 77     }
 78     output << ")\n";
 79 }
 80 int main(int argc, const char * argv[]) {
 81
 82     cout<<"*********添加整型元素*************\n";
 83     Stack<int> stack;
 84     for (int i=0; i<5; i++) {
 85         stack.push(i*10);
 86     }
 87     stack.printOn(cout);
 88
 89     cout<<"*********删除浮点型元素*************\n";
 90     Stack<float> stack1;
 91     for (int i=0; i<5; i++) {
 92         stack1.push(i*10);
 93     }
 94     for (int i=0; i<5; i++) {
 95         float f;
 96         stack1.pop(f);
 97         cout << f <<endl;
 98     }
 99     stack1.printOn(cout);
100
101     cout<<"*********添加字符元素*************\n";
102
103     char* c[5]={"one", "two", "three", "four", "five"};
104     Stack<char*> stack2;
105     for (int i=0; i<5; i++) {
106         stack2.push(c[i]);
107     }
108     stack2.printOn(cout);
109
110     return 0;
111 }

3. 类模板默认值与多个模板参数

 1 #include <iostream>
 2 using namespace std;
 3
 4 template <typename T = int>
 5 class A {
 6     T t;
 7 public:
 8     A(){
 9         t = 10;
10     }
11     void print(){
12         cout << t << endl;
13     }
14 };
15
16
17 template <typename T1 ,typename S>
18 void test(T1 t, S s) {
19     cout << t << endl;
20     cout << s << endl;
21 }
22 int main(int argc, const char * argv[]) {
23     cout<<"*********类模板默认值**********\n";
24     A<> a;
25     a.print();
26
27     cout<<"*********多个模板参数**********\n";
28     int m = 20;
29     char* n = "Hello";
30     test(m, n);
31
32     return 0;
33 }