头歌程序设计二（面向对象）_实训13_虚函数

第1关：设计和使用虚函数

测试说明

本关一共 4 个文件，其中List.h提供了 List 类。List 类提供 5 个虚函数，其中有 4 个是纯虚函数，需要用户在子类中实现。ArrayList.h提供了 ArrayList 类，LinkedList.h 提供了 LinkedList 类。这 2 个类都是 List 的派生类。
List.h 内容如下：

1. #ifndef _LIST_H_
2. #define _LIST_H_
4. #include <iostream>
5. using std::ostream;
6. using std::endl;
8. class List{
9. protected:
10. int size;
12. public:
13. //兼具默认构造函数和功能构造函数
14. List(int s=0):size(s){}
15. //拷贝构造函数
16. List(const List&rhs):size(rhs.size){}
18. /*以下为虚函数*/
19. //作为继承的基类的析构函数一定要是虚的
20. virtual ~List(){}
22. /*以下为纯虚函数，即没有实现*/
23. virtual void insert(int pos,int value)=0;
24. virtual void remove(int pos)=0;
25. virtual int at(int pos)const=0;
26. virtual void modify(int pos,int newValue)=0;
28. /*以下为普通的虚函数，有实现*/
29. virtual void disp(ostream&os)const{
30. for(int i=0,n=getSize();i<n;++i){
31. os<<at(i)<<" ";//注意，这里at函数并没有实现
32. //但不妨碍这么写
33. }
34. os<<endl;
35. }
36. };
38. #endif // _LIST_H_

ArrayList.h 内容如下：

1. #ifndef _ARRAYLIST_H_
2. #define _ARRAYLIST_H_
4. #include "List.h"
6. class ArrayList : public List{
7. private:
8. int *data; //真正保存数据的地方
9. int capacity;//容量
11. public:
12. //默认构造函数，构造一个逻辑为空的顺序表
13. ArrayList();
14. //拷贝构造函数，构造一个逻辑上与参数内容相同的顺序表
15. ArrayList(const ArrayList&rhs);
16. //原生数组构造函数，构造一个内容与给定数组相同的顺序表
17. ArrayList(int const a[],int n);
18. //填充构造函数，构造一个内容为n个value的顺序表
19. ArrayList(int n,int value);
20. //析构函数，一定要自行实现，否则有内存泄漏
21. ~ArrayList();
23. //子类当中须覆盖并实现父类中的纯虚函数
24. void insert(int pos,int value);
25. void remove(int pos);
26. int at(int pos)const;
27. void modify(int pos,int newValue);
29. //对于父类中已实现的虚函数，可以选择覆盖或者不覆盖
30. //void disp(ostream&os)const;//这个函数可以直接使用父类中的实现
31. };
33. #endif // _ARRAYLIST_H_

LinkedList.h 内容如下：

1. #ifndef _LINKEDLIST_H_
2. #define _LINKEDLIST_H_
4. #include "List.h"
6. class LinkedList : public List{
7. public:
8. //这是单链表节点的结构体
9. struct Node{
10. int data;
11. Node *next;
12. Node(int a=0,Node *b=nullptr):data(a),next(b){}
13. };
15. private:
16. Node *head;//链表的头结点
18. public:
19. //默认构造函数，构造一个逻辑为空的链表
20. LinkedList();
21. //拷贝构造函数，构造一个逻辑上与参数内容相同的链表
22. LinkedList(const LinkedList&rhs);
23. //原生数组构造函数，构造一个内容与给定数组相同的链表
24. LinkedList(int const a[],int n);
25. //填充构造函数，构造一个内容为n个value的链表
26. LinkedList(int n,int value);
27. //析构函数，一定要自行实现，否则有内存泄漏
28. ~LinkedList();
30. //子类当中须覆盖并实现父类中的纯虚函数
31. void insert(int pos,int value);
32. void remove(int pos);
33. int at(int pos)const;
34. void modify(int pos,int newValue);
36. //对于父类中已实现的虚函数，可以选择覆盖或者不覆盖
37. //对于LinkedList子类，必须重新实现disp函数
38. void disp(ostream&os)const;
39. };
42. #endif // _LINKEDLIST_H_

main.cpp 内容如下：

1. #include <iostream>
2. #include "List.h"
3. #include "ArrayList.h"
4. #include "LinkedList.h"
5. using namespace std;
7. int A[1000];
8. int main(){
9. //所有调用都通过基类的指针实现
10. //如无特殊要求，绝不定义派生类类型的变量
11. List *p = new ArrayList;
12. int n;
13. cin>>n;
14. for(int i=0;i<n;++i){
15. cin>>A[i];
16. p->insert(p->getSize(),A[i]);
17. }
18. p->disp(cout);
19. for(int i=0;i<3&&p->getSize()!=0;++i){
20. p->remove(0);
21. }
22. p->disp(cout);
23. for(int i=0;i<p->getSize();i+=2){
24. p->modify(i,p->at(i)*10);
25. }
26. p->disp(cout);
27. delete p;
29. p = new LinkedList;
30. for(int i=0;i<n;++i){
31. p->insert(p->getSize(),A[i]);
32. }
33. p->disp(cout);
34. for(int i=0;i<3;&&p->getSize()!=0;++i){
35. p->remove(0);
36. }
37. p->disp();
38. for(int i=0;i<p->getSize();i+=2){
39. p->modify(i,p->at(i)*10);
40. }
41. p->disp(cout);
42. delete p;
43. return 0;
44. }

#include "ArrayList.h"

/****************start from here**********************/
#include"List.h"
#include<iostream>
using namespace std;
  ArrayList::ArrayList()
    {
        data=new int[1005];
        capacity=0;
        size=0;
    }
   ArrayList::~ArrayList()
    {
        delete [] data;
    }

    void ArrayList::insert(int pos,int value)
    {
        data[pos]=value;
        capacity++;
        size++;
    }
    void ArrayList::remove(int pos)
    {
        for(int i=0;i<capacity;i++) 
            data[i]=data[i+1];
        capacity--;
        size--;
    }
    int ArrayList::at(int pos)const
    {
        return data[pos];
    }
    void ArrayList::modify(int pos,int newValue)
    {
        data[pos]=newValue;
    }

第2关：普通非成员函数的动态绑定

建立一个继承体系，List 是基类，ArrayList 和 LinkedList 是其派生类。并且编写实现下述函数并达到如下效果。

1. ostream& operator << (ostream&os, const List&rhs);

做一个流输出运算符重载，其第二个参数是List的常引用类型。我们知道子类的对象天生可以作为父类类型使用，因此

1. ArrayList a;
2. LinkedList b;
3. operator << (cout,a);
4. operator << (cout,b);

这上面的调用显然都是合法的。但是现在要求实现如下效果：第 3 行的函数执行的是适合 ArrayList 输出的代码，而第 4 行执行的是适合 LinkedList 输出的代码。即，虽然调用的函数一样，但需要根据当时的实参类型选择合适的实现。相当于对非成员函数做到动态绑定。

/****************start from here**********************/
#include "ArrayList.h"
#include"List.h"
#include<iostream>
using namespace std;
   ArrayList::ArrayList()
    {
        data=new int[1005];
        capacity=0;
        size=0;
    }
   ArrayList::~ArrayList()
    {
        delete [] data;
    }
    //
    void ArrayList::insert(int pos,int value)
    {
        data[pos]=value;
        capacity++;
        size++;
    }
    void ArrayList::remove(int pos)
    {
        for(int i=0;i<capacity;i++) 
            data[i]=data[i+1];
        capacity--;
        size--;
    }
    int ArrayList::at(int pos)const
    {
        return data[pos];
    }
    void ArrayList::modify(int pos,int newValue)
    {
        data[pos]=newValue;
    }

第3关：接口继承

测试说明

用户需要编写 IList 类，IList 类只提供 5 个纯虚函数，分别是增、删、查、改和显示函数。另外，考虑到 C++ 的语法需要，IList 类还需要定义一个虚函数的析构函数。
其他文件包括 List.h、ArrayList.h、ArrayList.cpp、LinkedList.h、LinkedList.cpp 和 main.cpp。
List.h 内容如下：

1. #ifndef _LIST_H_
2. #define _LIST_H_
4. #include "IList.h"
6. class List : public IList{//抽象父类直接继承接口
7. protected:
8. int size;
10. public:
11. //兼具默认构造函数和功能构造函数
12. List(int s=0):size(s){}
13. //拷贝构造函数
14. List(const List&rhs):size(rhs.size){}
16. //析构函数一定要是虚的
17. virtual ~List(){}
19. int getSize()const{return size;}
21. /*现在不用再声明那些纯虚函数*/
22. /*因为都从接口继承了*/
24. /*这是一个可以实现的从接口继承而来的虚函数*/
25. void disp(ostream&os)const{
26. for(int i=0;i<size;++i){
27. os<<at(i)<<" ";//注意，这里at函数并没有实现
28. //但不妨碍这么写
29. }
30. os<<endl;
31. }
32. };
34. #endif // _LIST_H_

ArrayList.h 内容如下：

1. #ifndef _ARRAYLIST_H_
2. #define _ARRAYLIST_H_
4. #include "List.h"
6. class ArrayList : public List{
7. private:
8. int *data; //真正保存数据的地方
9. int capacity;//容量
11. public:
12. //默认构造函数，构造一个逻辑为空的顺序表
13. ArrayList();
14. //拷贝构造函数，构造一个逻辑上与参数内容相同的顺序表
15. ArrayList(const ArrayList&rhs);
16. //原生数组构造函数，构造一个内容与给定数组相同的顺序表
17. ArrayList(int const a[],int n);
18. //填充构造函数，构造一个内容为n个value的顺序表
19. ArrayList(int n,int value);
20. //析构函数，一定要自行实现，否则有内存泄漏
21. ~ArrayList();
23. /*虚函数，但是子类中可以不用写virtual*/
24. void insert(int pos,int value);
25. void remove(int pos);
26. int at(int pos)const;
27. void modify(int pos,int newValue);
29. private:
30. void setCapacity(int newCapa);
31. };
33. #endif // _ARRAYLIST_H_

ArrayList.cpp 的内容如下：

2. #include "ArrayList.h"
4. ArrayList::ArrayList():List(0),data(nullptr),capacity(0){
5. capacity = 1;
6. data = new int [capacity];
7. }
9. ArrayList::ArrayList(const ArrayList&rhs):List(rhs),data(nullptr),capacity(0){
10. capacity = size;
11. data = new int [capacity];
12. for(int i=0;i<size;++i){
13. data[i] = rhs.data[i];
14. }
15. }
17. ArrayList::ArrayList(int const a[],int n):List(n),data(nullptr),capacity(0){
18. capacity = size;
19. data = new int [capacity];
20. for(int i=0;i<size;++i){
21. data[i] = a[i];
22. }
23. }
25. ArrayList::ArrayList(int n,int value):List(n),data(nullptr),capacity(0){
26. capacity = size;
27. data = new int [capacity];
28. for(int i=0;i<size;++i){
29. data[i] = value;
30. }
31. }
33. ArrayList::~ArrayList(){
34. delete [] data;
35. }
37. void ArrayList::setCapacity(int newCapa){
38. if ( newCapa <= capacity ){
39. return;
40. }
42. int *p = new int [capacity=newCapa];
43. for(int i=0;i<size;++i){
44. p[i] = data[i];
45. }
46. delete data;
47. data = p;
48. }
50. void ArrayList::insert(int pos,int value){
51. if ( size == capacity ){
52. setCapacity(capacity<<1);
53. }
55. for(int i=size-1;i>=pos;--i){
56. data[i+1] = data[i];
57. }
58. data[pos] = value;
59. ++size;
60. }
62. void ArrayList::remove(int pos){
63. for(int i=pos;i<size-1;++i){
64. data[i] = data[i+1];
65. }
66. --size;
67. }
69. int ArrayList::at(int pos)const{
70. return data[pos];
71. }
73. void ArrayList::modify(int pos,int newValue){
74. data[pos] = newValue;
75. }

LinkedList.h 内容如下：

1. #ifndef _LINKEDLIST_H_
2. #define _LINKEDLIST_H_
4. #include "List.h"
6. class LinkedList : public List{
7. public:
8. //这是单链表节点的结构体
9. struct Node{
10. int data;
11. Node *next;
12. Node(int a=0,Node *b=nullptr):data(a),next(b){}
13. };
15. private:
16. Node *head;//链表的头结点
18. public:
19. //默认构造函数，构造一个逻辑为空的链表
20. LinkedList();
21. //拷贝构造函数，构造一个逻辑上与参数内容相同的链表
22. LinkedList(const LinkedList&rhs);
23. //原生数组构造函数，构造一个内容与给定数组相同的链表
24. LinkedList(int const a[],int n);
25. //填充构造函数，构造一个内容为n个value的链表
26. LinkedList(int n,int value);
27. //析构函数，一定要自行实现，否则有内存泄漏
28. ~LinkedList();
30. /*虚函数，但是子类中可以不用写virtual*/
31. void insert(int pos,int value);
32. void remove(int pos);
33. int at(int pos)const;
34. void modify(int pos,int newValue);
36. /*另外，出于效率考虑，还需要重新实现disp函数，覆盖基类的同名函数*/
37. void disp(ostream&os)const;
39. private:
40. Node* advance(int pos)const;
41. };
44. #endif // _LINKEDLIST_H_

LinkedList.cpp 内容如下：

1. #include "LinkedList.h"
3. LinkedList::LinkedList():List(),head(nullptr){
4. head = new Node;
5. }
7. LinkedList::LinkedList(const LinkedList&rhs):List(rhs),head(nullptr){
8. head = new Node;
9. Node *q = head;
10. for(Node*p=rhs.head->next;p;p=p->next){
11. q->next = new Node(p->data);
12. q = q->next;
13. }
14. }
16. LinkedList::LinkedList(int const a[],int n):List(n),head(nullptr){
17. head = new Node;
18. Node *q = head;
19. for(int i=0;i<n;++i){
20. q->next = new Node(a[i]);
21. q = q->next;
22. }
23. }
25. LinkedList::LinkedList(int n,int value):List(n),head(nullptr){
26. head = new Node;
27. Node *q = head;
28. for(int i=0;i<n;++i){
29. q->next = new Node(value);
30. q = q->next;
31. }
32. }
34. LinkedList::~LinkedList(){
35. while( getSize() ){
36. remove(0);
37. }
38. delete head;
39. }
41. LinkedList::Node* LinkedList::advance(int pos)const{
42. Node *p=head;
43. for(int i=-1;i<pos;++i)p=p->next;
44. return p;
45. }
47. void LinkedList::insert(int pos,int value){
48. Node *p = advance(pos-1);
49. Node *q = new Node(value,p->next);
50. p->next = q;
51. ++size;
52. }
54. void LinkedList::remove(int pos){
55. Node *p = advance(pos-1);
56. Node *q = p->next;
57. p->next = q->next;
58. delete q;
59. --size;
60. }
62. int LinkedList::at(int pos)const{
63. return advance(pos)->data;
64. }
66. void LinkedList::modify(int pos,int newValue){
67. advance(pos)->data = newValue;
68. }
70. void LinkedList::disp(ostream&os)const{
71. for(Node*p=head->next;p;p=p->next){
72. os<<p->data<<" ";
73. }
74. }

最后，main.cpp 内容如下：

1. #include "List.h"
2. #include "ArrayList.h"
3. #include "LinkedList.h"
4. using namespace std;
6. int A[1000];
7. int main(){
8. List *p = new ArrayList;
9. int n;
10. cin>>n;
11. for(int i=0;i<n;++i){
12. cin>>A[i];
13. p->insert(p->getSize(),A[i]);
14. }
15. p->disp(cout);
16. for(int i=0;i<3&&p->getSize()!=0;++i){
17. p->remove(0);
18. }
19. p->disp(cout);
20. for(int i=0;i<p->getSize();i+=2){
21. p->modify(i,p->at(i)*10);
22. }
23. p->disp(cout);
24. delete p;
26. p = new LinkedList;
27. for(int i=0;i<n;++i){
28. p->insert(p->getSize(),A[i]);
29. }
30. p->disp(cout);
31. for(int i=0;i<3&&p->getSize()!=0;++i){
32. p->remove(0);
33. }
34. p->disp(cout);
35. for(int i=0;i<p->getSize();i+=2){
36. p->modify(i,p->at(i)*10);
37. }
38. p->disp(cout);
39. delete p;
40. return 0;
41. }

    #ifndef _ILIST_H_
    #define _ILIST_H_
    /****************start from here**********************/
    #include<iostream>
    using namespace std;
    class IList
    {
        public:
        virtual void insert(int pos,int value)=0;  
        virtual void remove(int pos)=0;  
        virtual int at(int pos)const=0;  
        virtual void modify(int pos,int newValue)=0;
        virtual void disp(ostream&os)const{};
    };
    
    
    #endif