C++的继承实现之公有继承

公有继承

class Base
{
   //...base class members   
};
class Derived : access-specifier Base
{
   //..derived class members
};

其中的access-specifier 可以是public,private,或是protected.

与public和private一样，protected也是一个访问限定符。将属性声明为protected的时，相当于允许派生类和友元类访问它，但禁止在继承层次结构外部（包括main( )）访问它。使用protected关键字，只有派生类和友元类才能访问。

包含初始化列表的派生类构造函数：

#include<iostream>
using namespace std;
class Fish
{
protected:
    bool isFreshWaterFish;
public:
    Fish(bool isFreshWater):isFreshWaterFish(isFreshWater){}

    void Swim()
    {
        if(isFreshWaterFish)
            cout<<"Swims in lake"<<endl;
        else
            cout<<"Swims in sea"<<endl;
    }
};

class Tuna:public Fish
{
public:
    Tuna():Fish(false){}//constructor initializes base
};
int main()
{
    Tuna myDinner;
    cout<<"Dinner :";
    myDinner.Swim();
    return 0;

}

如果派生类实现了从基类继承的函数，且返回值和特征标相同，就相当于覆盖率基类的这个方法。

#include<iostream>
using namespace std;
class Fish
{
protected:
    bool isFreshWaterFish;
public:
    Fish(bool isFreshWater):isFreshWaterFish(isFreshWater){}

    void Swim()
    {
        if(isFreshWaterFish)
            cout<<"Swims in lake"<<endl;
        else
            cout<<"Swims in sea"<<endl;
    }
};

class Tuna:public Fish
{
public:
    Tuna():Fish(false){}//constructor initializes base
    void Swim()
    {
        cout<<"Tuna swims real fast"<<endl;
    }
};
int main()
{
    Tuna myDinner;
    cout<<"Dinner :";
    myDinner.Swim();
    return 0;

}

此时，派生类实例化的对象调用Swim()方法，调用的是在派生类里面的Swim()方法。在派生类中调用基类的办法：用作用域解析运算符（::）可以调用基类中的方法。

在实例中调用已经被隐藏的基类方法：

1. 在main()函数中使用作用域解析运算符：

myDinner.Fish::Swim();

2.在派生子类中，使用关键字using解除对于基类方法的隐藏：

class Tuna: public Fish
{
public:
    using Fish::Swim;
    void Swim ()
    {
        cout<<" "<<endl;
    }
};

3.通过派生子类的Swim()方法，来调用基类中的Swim()方法：

class Tuna:public Fish
{
public:
    Tuna():Fish(false){}//constructor initializes base
    void Swim(isFreshWaterFish)
    {
        Fish::Swim(isFreshWaterFish);
    }
    void Swim()
    {
        cout<<"Tuna swims real fast"<<endl;
    }
};

接下来的程序说明了在类实例化构造对象的时候，构造函数调用的顺序，以及析构函数调用的顺序：

#include<iostream>
using namespace std;
class FishDummyMember
{
public:
    FishDummyMember()
    {
        cout<<"FishDummyMember constructor"<<endl;
    }
    ~FishDummyMember()
    {
        cout<<"FishDummyMember destructor"<<endl;
    }
};
class Fish
{
protected:
    FishDummyMember dummy;
public:
    Fish()
    {
        cout<<"Fish constructor"<<endl;
    }
    ~Fish()
    {
        cout<<"Fish destructor"<<endl;
    }
};
class TunaDummyMember
{
public:
    TunaDummyMember()
    {
        cout<<"TunaDummyMember constructor"<<endl;
    }
    ~TunaDummyMember()
    {
        cout<<"TunaDummyMember destructor"<<endl;
    }
};
class Tuna: public Fish
{
private:
    TunaDummyMember dummy;
public:
    Tuna()
    {
        cout<<"Tuna constructor"<<endl;
    }
    ~Tuna()
    {
        cout<<"Tuna destructor"<<endl;
    }

};
int main()
{
   Tuna myDinner;
}

从上面的结果可以看出，类在实例化对象的时候，的构造顺序和析构顺序是相反的。

C++的继承实现之公有继承

猜你喜欢