C++学习五：类继承、基类（父类）和派生类（子类）、公有继承（public继承）、私有继承（private继承）、保护继承（protected继承）、子类构造函数和析构函数、is-a、has-a关系。

一.类继承

1.概念

    用已有的类来建立专用类的编程技术；

2.目的

    实现代码重用

3.父类/基类 和  子类/派生类

    父类:已有的类叫父类,是抽象类

    子类:由基类派生出来的类叫派生类/子类，是父类的具体化

派生类的构造函数一般有3项工作要完成：首先 基类初始化 ，其次 成员对象初始化，最后 执行派生类构造函数体

4.语法形式

    class 子类名 : 权限限定符 基类名1, 权限限定符 基类名2....

    {

        //class body

    };

       eg1：public继承

         //子类:public继承
        //基类的public成员 -> 子类的public成员
        //基类的protected成员 -> 子类的protected成员
        //基类的private成员只能通过基类的接口访问

        //public继承
        class Base{
            public:
                Base(int val = 0) : val(val)
                {
                    cout << __func__ << ":" << __LINE__ << endl;
                }
                ~Base()
                {
                    cout << __func__ << ":"<<__LINE__ << endl;
                }
                int getval() const;
            protected:
                void setval(int);
            private:
                int val;
        };
        void Base::setval(int val)
        {
            this->val = val;
        }
        int Base::getval() const
        {
            return this->val;
        }
        //子类:public继承
        //基类的public成员 -> 子类的public成员
        //基类的protected成员 -> 子类的protected成员
        //基类的private成员只能通过基类的接口访问
        class Inherit : public Base{
            public:
                Inherit(int val=0);
                ~Inherit();
            public:
                void setmyval(int);
                int getmyval() const;
            private:
                int myval;
        };

        Inherit::Inherit(int val) : myval(val)
        {
            cout << __func__ << ":" << __LINE__ << endl;
        }
        Inherit::~Inherit()
        {
            cout << __func__ << ":" << __LINE__ << endl;
        }
        void Inherit::setmyval(int v)
        {
            setval(v);//基类的protected成员在子类的访问权限是protected
            //val++;//基类的private成员只能通过基类接口访问
            this->myval = v;
        }
        int Inherit::getmyval() const
        {
            return this->myval;
        }
        int main()
        {  
            Inherit obj;
            cout << sizeof obj << endl;
            //obj.setval(666);//protected成员只能在类内部或子类内部访问
            obj.setmyval(888);
            cout << obj.getval() << endl;
            return 0;
        }

           

    eg2：protected继承

        //子类:protected继承
        //基类的public成员 -> 子类的protected成员
        //基类的protected成员 -> 子类的protected成员
        //基类的private成员只能通过基类的接口访问

class Base{
            public:
                Base(int val = 0) : val(val)
                {
                   cout << __func__ << ":" << __LINE__ << endl;
                }
                ~Base()
                {
                    cout << __func__ << ":"<<__LINE__ << endl;
                }
                int getval() const;
            protected:
                void setval(int);
            private:
                int val;
        };

        void Base::setval(int val)
        {
            this->val = val;
        }
        int Base::getval() const
        {
            return this->val;
        }
        //子类:protected继承
        //基类的public成员 -> 子类的protected成员
        //基类的protected成员 -> 子类的protected成员
        //基类的private成员只能通过基类的接口访问
        class Inherit : protected Base{
            public:
                Inherit(int val=0);
                ~Inherit();
            public:
                void setmyval(int);
                int getmyval() const;
            private:
                int myval;
        };
        Inherit::Inherit(int val) : myval(val)
        {
            cout << __func__ << ":" << __LINE__ << endl;
        }
        Inherit::~Inherit()
        {
            cout << __func__ << ":" << __LINE__ << endl;
        }
        void Inherit::setmyval(int v)
        {
            setval(v);//基类的protected成员在子类的访问权限是protected
            cout << getval() << endl;
            //val++;//基类的private成员只能通过基类接口访问
            this->myval = v;
        }
        int Inherit::getmyval() const
        {
           return this->myval;
        }
        int main()
        { 
            Inherit obj;
            cout << sizeof obj << endl;
            //obj.setval(666);//protected成员只能在类内部或子类内部访问
            obj.setmyval(888);
            //cout << obj.getval() << endl;//protected继承:基类的public在子类的访问权限?
            return 0;
        }

       

    eg3：private继承

       //子类:private继承
        //基类的public成员 -> 子类的private成员
        //基类的protected成员 -> 子类的private成员
        //基类的private成员只能通过基类的接口访问

class Base{

            public:
                Base(int val = 0) : val(val)
                {
                    cout << __func__ << ":" << __LINE__ << endl;
                }
                ~Base()
                {
                    cout << __func__ << ":"<<__LINE__ << endl;
                }
                int getval() const;
            protected:
                void setval(int);
            private:
                int val;
        };
        void Base::setval(int val)
        {
            this->val = val;
        }
        int Base::getval() const
        {
            return this->val;
        }
        //子类:private继承
        //基类的public成员 -> 子类的private成员
        //基类的protected成员 -> 子类的private成员
        //基类的private成员只能通过基类的接口访问
class Inherit : private Base{
            public:
                Inherit(int val=0);
                ~Inherit();
            public:
                void setmyval(int);
                int getmyval() const;
            private:
                int myval;
        };
        Inherit::Inherit(int val) : myval(val)
        {
            cout << __func__ << ":" << __LINE__ << endl;
        }

        Inherit::~Inherit()
        {
            cout << __func__ << ":" << __LINE__ << endl;
        }
        void Inherit::setmyval(int v)
        {
            setval(v);//基类的protected成员在子类的访问权限是protected
            cout << getval() << endl;
            //val++;//基类的private成员只能通过基类接口访问
            this->myval = v;
        }
        int Inherit::getmyval() const
        {
            return this->myval;
        }
        int main()
        {  
            Inherit obj;
            cout << sizeof obj << endl;
            //obj.setval(666);//protected成员只能在类内部或子类内部访问
            obj.setmyval(888);
            //cout << obj.getval() << endl;//protected继承:基类的public在子类的访问权限?
            return 0;
        }

       

    总结:

        1)public继承

            基类的public成员 -> 子类的public成员

            基类的protected成员 -> 子类的protected成员

            基类的private成员只能通过基类的接口访问

        2)protected继承

            基类的public成员 -> 子类的protected成员

            基类的protected成员 -> 子类的protected成员

            基类的private成员只能通过基类的接口访问

        3)private继承

            基类的public成员    -> 子类的private成员

            基类的protected成员 -> 子类的private成员

            基类的private成员只能通过基类的接口访问

 二.子类构造函数和析构函数

1.注意

    构造函数和析构不能够被继承；

    每个类都有自己的构造和析构

2.顺序

    先构造基类对象，再构造子类对象

    先析构子类对象，再析构基类对象

三.is-a关系

描述继承关系，即派生类一定是基类的一种

例：水果有香蕉，水果类和香蕉类之间就是is-a关系

四.has-a关系

用来描述组合关系

例如:午餐有水果，午餐类和水果类之间的关系就是has-a关系

五.多重继承

1.语法形式

    class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…

    {

          <派生类类体>

    }；

    eg:       

class Man{
        public:
            Man()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
            ~Man()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
        public:
            void prnmsg()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
        };       
class Wolf{
        public:
            Wolf()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
            ~Wolf()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
        };

        //多重继承
class WolfMan : public Man, public Wolf{
        public:
            WolfMan()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
            ~WolfMan()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
        };
        int main()
        {
            WolfMan obj;
            return 0;

        }