程序设计B之C++继承和多态 我的总结

继承:

在要定义一个新的类B时，如果该类与某个已有的类A相似就是B拥有A的全部特点),
那么就可以把A作为一个基类，而把B作为基类的一个派生类或者子类。而A与B有相同的部分就不用再重复写一遍。

派生类：
拥有基类的全部特点，并且派生类是通过对基类进行修改和扩充得到的。
特点一就是在派生类中，可以扩充新的成员变量和成员函数。
特点二就是在派生类中，编写与基类函数名一样的函数，而这个函数的功能与原来的不同。

派生类的创造函数
在创建派生类的对象时:
（1) 先执行基类的构造函数，用以初始化派生类对象中从基类继承的成员;
（2)再执行成员对象类的构造函数，用以初始化派生类对象中成员对象。
（3)最后执行派生类自己的构造函数
特点
（1） 派生类拥有基类的全部成员函数和成员变量，不论是pr ivate、protected、 public。
（2）在派生类的各个成员函数中，不能访问基类中的private成员。

派生类的析构函数则相反：
在派生类对象消亡时:
1)先执行派生类自己的析构函数
2)再依次执行各成员对象类的析构函数
3)最后执行基类的析构函数

例如

class Find{
protected:
    vector<Book> a;                                                       
    multimap<string,int> bookname;                                         
    multimap<string,int> booknumber;                                    
    multimap<string,int> author;                                        
    multimap<string,int> borrowedrecord_1;                                     
    multimap<string,int> borrowedrecord_2;                                   
    multimap<Date,int>   publishtime;                                          
    vector<BorrowedRecord> c;                                                  
public:
    Find();
    ~Find();
    bool findBookByNumber(string booknumber);                                  
    bool findBookByName(string bookname);                                     
    bool findBookByPublisher(string publisher);                                
    bool findBookByPublishtime(Date publishtime);                          
    void findBookByNameHazily(string keyword);                                
    bool match(multimap<string,int>::iterator it,string s1);                 
    bool findBookByCombination_1(string bookname,string author);              
    bool findBookByCombination_2(string publisher,string author);             
    bool findBookByTimeIntervals(Date date_1,Date date_2);                  
    void findRecordByNumber(string booknumber);                              
    void findMyselfRecordByBookType(string booktype);                        
    
};
//操作类
class Operation:public Find{
    Reader b;                                                                  
    Date today;                                                                
public:
    Operation(Reader &b,Date today);
    ~Operation();
    void ReaderSave();                                                       
    void BorrowedRecordSave();                                                
    void BorrowedRecordOpen();                                               
    void BookSave();                                                         
    void BookOpen();                                                      
    void addBook(Book &b);                                                    
    void borrowBook(string booknumber);                                       
    void returnBook(string booknumber);                                        
    void renewBook(string booknumber);                                         
};

就是操作类继承了查询类，查询类为基类，操作类为父类。所以派生类的生成过程经历了三个步骤：

吸收基类成员（全部吸收（构造、析构除外），但不一定可见）：吸收基类成员我是这样理解，就是派生类里除了基类的构造、析构函数没有这些，剩下的全部成员它全都有。但是我们需要注意一下，定义派生类对象时只是复制了基类对象的空间，复制过来的数据成员并没有被赋初值。

改造基类成员：
改造基类成员是用过在派生类中定义同名成员（其中包括成员函数和数据成员）来隐藏在派生类中不起作用的部分基类成员，我们可以
通过成员函数的覆盖来改造基类成员。

添加派生类新成员：
这里说一下函数覆盖和函数重载的区别，覆盖：函数名称、参数什么的都一样，而重载函数只是同名，其他的都可以不一样。
添加新成员是因为是因为仅仅继承基类的成员是不够的，需要在派生类中添加新成员，以保证派生类自身特殊属性和行为的实现

虚函数：
（1）在类的定义中，虚函数就是前面有virtual 关键字的成员函数。
例如：
class base {
virtual string get();
//这个“virtual”虚函数
};
int base:get() { }
（2）virtual 关键字只用在类定义里的函数声明中，类外写函数体时不需要用到关键字了。
（3）注意：构造函数和静态成员函数一定不能是虚函数。

多态：
派生类的指针可以赋给基类指针。通过基类指针调用基类和派生类中的同名虚函数时:
(1) 若指针指向一个基类的对象时被调用是基类的虚函数;
(2) 若该指针指向一个派生类的对象时被调用的是派生类的虚函数。