类（三）——继承与多态

 一、继承限定词（不写的话默认是private）

class X : public Y

public: 父类怎样，子类怎样

protected：父类的public在子类中变成protected

private： 父类的pubic和protected在子类中都变成private

总结：（注意区分 子类中，子类对象  这两个概念）

(1) 访问说明符的作用是控制子类用户(即子类的对象，不是子类内部)对于父类成员的访问权限，父类中比继承限定词高级的限定词语的等级将会在子类中会降为和继承限定词一样。

(2) 不论何种继承方式，父类的protected成员在子类中(即子类内部，不是子类对象)可以直接访问，但是外界定义的子类对象不能访问。

(3) 不论何种继承方式，父类的private成员不论是在子类中，还是对于子类的对象都不可以访问。

(4) 不论何种继承方式，父类的protected成员在子类中都是可见的，父类的private成员在子类中都是不可见的，但是子类还是继承了父类的private成员。

               

#include <iostream>

using namespace std;

class Father
{
private:
    int a;
    float b;

};

class Son : private Father
{

};

int main()
{
    cout << sizeof(Son) << endl;    //输出结果为8，说明子类继承了父类的private成员
    return 0;
}

二、使用using修改父类个别成员在子类中的可访问性(不能对父类的private成员使用using声明，即不能修改父类的private成员在子类中的访问权限)

using声明语句中名字的访问权限由该using声明语句之前的访问说明符来决定。子类只能为那些它可以访问的名字提供using声明。(所以在子类中不能对父类的private成员使用using声明，即在子类中不能使用using声明修改父类private成员在子类中的访问权限)。

using声明不受继承方式的影响。

class Father
{
public:
    int size() const {return n;}
protected:
    int n = 5;
private:
    int m = 3;

};

class Son : private Father     //using声明不受继承方式的影响
{
private:
    using Father::size;       //正确：使用using声明将继承自Father类中public的size()成员修改为了private(在父类中size()是public的，在子类中size()被修改为了private)
public:
    using Father::n;          //正确：使用using声明将Father类中protected的n修改为了public(在父类中n是protected的，在子类中n被修改为了public)
    using Father::m;          //错误：不能使用using修改父类private成员在子类中的访问权限！
};

三、构造函数和析构函数的调用顺序：

1、子类构建对象时，先调用父类的构造函数，再调用子类的构造函数。

2、子类的对象销毁时，先调用子类的析构函数，再调用父类的析构函数。    ( 即调用子类的析构函数时，一定会在之后同时调用父类的析构函数。)

3、可以在子类构造函数的初始化列表里面显式的调用父类的带参构造函数。

(1)

#include <iostream>

using namespace std;

class GrandFarther
{
public:
    GrandFarther()
    {
        cout << "GrandFarther();" << endl;
    }
    ~GrandFarther()
    {
        cout << "~GrandFarther();" << endl;
    }
};
class Father : public GrandFarther
{
public:
    Father()
    {
        cout << "Father();" << endl;
    }
    ~Father()
    {
        cout << "~Father();" << endl;
    }
};
class Son : public Father
{
public:
    Son()
    {
        cout << "Son();" << endl;
    }
    ~Son()
    {
        cout << "~Son();" << endl;
    }
};

int main()
{
    Son xiaoming;
    return 0;
}

输出为：

GrandFarther();

Farther();

Son();

~Son();

~Farther(); 

~GrandFarther();

 (2)

#include <iostream>

using namespace std;

class father
{
public:
    father()
    {
        cout << "father()" << endl;
    }
    father(int a, int b)
    {
        printf("father(%d,%d)
", a, b);
    }
};

class son : public father
{
public:
    son() : father(1,2)   //显式调用father(int a，int b)
    {
        cout << "son()" << endl;
    }
};
int main()
{
    son xiaoming;

    return 0;
}

输出为：

father(1,2)

son()

(3) 调用子类的析构函数时，一定会在之后同时调用父类的析构函数。

#include <iostream>

using namespace std;

class father
{
public:
    virtual ~father()
    {
        cout << "~father()" << endl;
    }
};

class son : public father
{
public:
    ~son()
    {
        cout << "~son()" << endl;
    }
};
int main()
{
    son* p1 = new son;
    delete p1;          //delete先调用~son(),再调用~father()。

    father* p2 = new son;
    delete p2;         //由于父类的析构函数是virtual的，所以此处delete销毁的是子类对象，故先调用~son(),再调用~father()。

    return 0;
}

四、virtual关键字 （主要是针对父类的指针指向子类的对象所产生的相关问题）  具体请参考：https://www.cnblogs.com/FengZeng666/p/9341861.html

(1) 构造函数不能是virtual的。

(2) static成员函数不能动态联编，所以静态函数不能是virtual的。

(3) 友元函数不能是virtual的。因为C++不支持友元函数的继承，对于没有继承特性的函数没有虚函数的说法。友元函数不属于类的成员函数，不能被继承。

(4) 函数前加virtual 关键字的作用：根据对象的类型，调用相应的函数（即保证调用的函数与对象类型一致）

#include <iostream>

using namespace std;

class father
{
public:
     void show()
    {
        cout << "show() in father" << endl;
    }

};

class son : public father
{
public:
    void show()
    {
        cout << "show() in son" << endl;
    }
};
int main()
{
    son s;
    father* p1 = &s;      
    father* p2 = new son;
    p1->show();   //当father类中的show()前没加virtual关键字时，调用的是father里面的show()；当father类中的show()前加了virtual关键字时，调用的则是son类里面的show()
29     p2->show();   //同上

    return 0; 
}

(5)当一个类被继承时，必须在父类的析构函数前加virtual，以避免潜在的问题。(父类的析构函数前加了virtual之后，子类的析构函数默认也是virtual的)

例如：

#include <iostream>

using namespace std;

class father
{
public:
    virtual ~father()
    {
        cout << "~father()" << endl;
    }
};

class son : public father
{
public:
    ~son()
    {
        cout << "~son()" << endl;
    }
};
int main()
{
    father* p1 = new son;
    delete p1;

    return 0;
}

当~father前面没有加virtual时，输出为~father()，说明delete调用的是father类的析构函数，然而我们指向的是一个son类型的对象，我们的本意是要其调用son的析构函数，这显然与我们的本意不符。所以加上~father()函数前virtual时，输出为 ~son()  回车  ~father() ，即delete调用了子类的析构函数，销毁的是一个son的对象，符合本意。又因为销毁子类对象时，会在之后同时调用父类的析构函数，所以之后也会输出~father() 

                                                    

 五、名字查找优先于类型检查

(1)声明在内层作用域的函数并不会重载声明在外层作用域的函数。因此，子类中与父类同名的函数并不会重载其在父类中的函数，即，子类将在其作用域内隐藏掉其父类中的同名函数成员(并不是重载)，即使形参列表不一致，父类成员也依然会被隐藏掉。

#include <iostream>

using namespace std;

class Father
{
public:
    void fun()
    {
        cout << "fun()" << endl;
    }
};

class Son : public Father
{
public:
    void fun(int)
    {
        cout << "fun(int)" << endl;
    }
};

int main()
{
    Father fa;
    Son so;
    fa.fun();              //调用父类中的fun()
    so.fun(10);            //调用子类中的fun(int)
    so.fun();              //错误：父类中的fun()被子类的fun()隐藏了(所以并不是重载的关系)
    so.Father::fun();      //正确：通过子类对象调用了父类中的fun()：使用作用域运算符
    return 0;

}