c++进阶之继承

继承相关概念

1）派生类将继承基类的数据和函数
代码：

class A  //基类（父类）
{
   public:
    void Func1(void);
    void Func2(void);
    int i=100;
};
class B :public A //子类（派生类），继承关系为public
{
   public:
    void Func3(void);
    void Func4(void);
};
int main(){
   B b;
   b.i;
   b.Func1();
   b.Func2();
   b.Func3();
   b.Func4();
}

2）继承可以调用基类的函数来实现自己的函数

class A  //基类（父类）
{
public:
    void Func1(void);
    void Func2(void);
};
class B :public A //子类（派生类），继承关系为public
{
 public:
    void Func3(void){
    A::Func1();/*为何不直接引用*/
  }
} 

成员访问限定符与继承的关系

继承与基类成员在派生类中的访问关系表

总结：
1）基类的私有成员在派生类中不能被访问，如果一些基类成员不想被基类对象直接访问，可以定义为保护成员。

2）public继承是一个接口继承，保持is-a原则（2.是什么？？），每个父类可用的成员对子类也可用，因为每个子类对象也是一个父类对象。

3）protect/private继承基类的部分成员并未成为子类的一部分，是has-a的关系原则（3.是什么？？），这种继承关系很少用，一般用public继承关系。

4）使用struct时的默认继承关系是public,而class时的默认继承关系是private，最好是把继承方式写出来

继承与转换

1）子类对象可以赋值给父类对象。 （补充原因）

2）父类对象不可以赋值给子类对象。（补充原因）

3）父类对象的指针和引用可以指向子类对象。

4）子类对象的指针和引用不能指向父类对象，但是可以通过强制转化完成。

代码：

class Person
{
public:
    void Print(){
         cout << _name << endl;
    }
protected:
    string _name;
};

class Student : public Person{
public:
    int _num;
};

void Test()
{
    Peron p;
    Student s;
    
    //子类对象可以赋值给父类对象
    p = s;
    
    //父类对象不可以赋值给子类对象
    //s = p;//error

    //父类对象的指针和引用可以指向子类对象
    Person *p1 = &s;
    Person& r1 = s;

    //子类对象的指针和引用不能指向父类的对象(但是可以通过强制类型转化完成)
    Student *p2 = (Student*)&p;
    Student& r2 = (Student&)p;

}

继承体系中的作用域

1）在继承体系中基类和派生类都有独立的作用域(如何理解？)

2）子类和父类中有同名成员，子类成员将屏蔽父类成员的直接访问。（在子类成员函数中，可以使用基类::基类成员访问）

3）注意尽量不要在继承体系中定义同名的成员。

代码：

class Person
{
public:
    Person(const char* name = "", int id = 0)
        :_name(name)/*初始化列表*/
        , _num(id)
    {}
protected:
    string _name;  
    int _num;      
};

class Student : public Person{
public:
    Student(const char *name, int id, int stuNum)
        :Person(name, id)/*注意基类和派生类初始化顺序*/
        , _num(stuNum)
        {}
    void DisplayNum()
    {
    cout << Person::_num << endl;/*注意理解访问与继承权限*/
    cout << _num << endl;
    }
protected:
    int _num;  
};

void Test()
{
    Student s1("paul", 110, 1);
    s1.DisplayNum();
}

派生类的默认成员函数

理解构造与析构函数的继承

代码：

class Person
{
public:
    Person(const char* name)
        :_name(name)
       {
        cout << "Person()" << endl;
    }
    Person(const Person& p)
       :_name(p._name){
       cout << "Person(const Person& p)" << endl;
    }
        
    Person& operator = (const Person& p){
       cout << "Person operatpr = (const Person& p)" << endl;
       if (this != &p)
        {
            _name = p._name;
        }
        return *this;
    }

      ~Person()
    {
        cout << "~person()" << endl;
    }
protected:
    string _name;//姓名
}；

class Student : public Person{
public:
     Student(const char* name, int num)
        :Person(name)
        , _num(num){
        cout << "student()" << endl;
        }
     Student(const Student& s)
        :Person(s)/*?*/
        ,_num(s._num)
        {
        cout << "Student(const Student& s)" << endl;
        }
      Student& operator = (const Student& s){
         cout << "Student& operator = (const Student& s)" << endl;
         if(this != &s){
            Person::operator=(s);/*单独赋值*/
            _num = s._num;
         }
         return *this;
        }
     ~Student()
    {
        cout << "~Student()" << endl;
    }
private:
    int _num; 
}；

void Test()
{
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;
}

菱型继承

如图：

菱形继承图·

注意：菱形继承的缺陷及解决方式（补充）

友元与继承

友元关系不能继承，也就是说基类友元不能访问子类私有和保护的成员（如何理解）
代码：

class Person
{
        friend void Display(Person& p, Student& s);
protected:
        string _name; 
}；

class Student : public Person
{
protected:
        int _stuNum;
}；

void Display(Person& p, Student& s)
{
    cout << p._name << endl;
    cout << s._name << endl;
    cout << s._stuNum << endl;
}
void Test()
{
    Person p;
    Student s;
    Display(p, s);
}

继承与静态成员

基类定义了static成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。（如何理解）

代码：

class Person
{
public:
    Person()
    {
        ++_count;
    }
protected:
    string __name;
public:
    static int _count;    
}；

int Person::_count = 0;/*注意静态成员的定义和初始化*/

class Student : public Person
{
protected:
   int _stuNum;
};

class Graduate : public Student
{
protected:
    string _seminarCourse; 
}；

void Test()
{
    Student s1;
    Student s2;
    Student s3;
    Graduate s4;
     cout << Person::_count << endl;

    Student::_count = 0;

    cout << Person::_count << endl;
}

虚函数

1.类的成员函数前面加virtual关键字。

2.虚函数重写：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写了父类的这个虚函数
注意：重写、重定义、重载的区别
如图：

注意：

1）派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同（协变除外）。（什么是协变）

3）只有类的成员函数才能定义虚函数。
4）如果在类外定义虚函数，只能在声明函数是加virtual，在类外定义函数时不能加virtual。

5）静态成员函数不能定义虚函数
6）不要在构造函数和析构函数里调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会发生未定义的行为
8）最好把析构函数声明为虚函数。因为派生类的析构函数跟基类的析构函数名称不一样，但是构成覆盖
代码：

class Person
{
public:
    virtual void BuyTickets()
    {
        cout << "买票" << endl;
    }
protected:
    string _name;
}；

class Student : public Person
{
public:
    virtual void BuyTickets()
    {
        cout << "买票-半价" << endl;
    }
protected:
    int _num;
 }；

void Fun(Person& p)
{
    p.BuyTickets();
}

void Test()
{
    Person p;
    Student s;
    Fun(p);
    Fun(s);
}