C++：公有，保护及私有继承

        从已有的类派生出新的类，而派生类继承了原有类的特征被称为类继承。下面按照访问权限分别介绍公有继承，私有继承与保护继承。

公有继承

        使用公有继承，基类的公有成员将成为派生类的公有成员（派生类对象可直接调用方法），基类的私有成员也将成为派生类的一部分，但只能通过基类的公有方法和保护方法访问。

class ttp{
private:
    string firstname;
    bool table;
public:
    ttp{string&fn,bool ht);
    void Name() const;
};//定义基类
//下面使用公有继承
class rpr:public ttp
{
private:
    usigned int rating;
public:
    rpr(usigned int r,string&fn,bool ht);
    rpr(usigned int r,ttp&tp);
}
    

        因为派生类只能通过基类的公有或保护方法访问基类私有数据，所以两个构造函数代码如下

rpr::rpr(usigned int r,string&fn,bool ht):ttp(fn,ht)//派生类构造函数将数据传给基类构造函数，创建一个嵌套的ttp对象
{
    rating=r
}
rpr::rpr(usigned int r,ttp&tp):ttp(tp)
{
    rating=r;    //也可使用列表初始化
}//调用复制构造函数

         若无显式调用的基类构造函数，则程序将调用默认的基类构造函数。最后对象过期时会先调用派生类的析构函数，再调用基类的析构函数。

基类与派生类的特殊关系

• 基类指针和引用可以在不进行显式转换类型的情况下指向派生类对象。（但只能用于调用基类方法）
• 可以用派生类对象为基类对象初始化。
• 可以将派生类对象赋值给基类对象。 

私有继承与包含（类）

        我们可以在类中嵌套其他的类，这种行为称为包含。下面设计一个student类来做相关介绍。

class student
{
private:
    string name;             //使用string类记录名字
    valarray<double> scores;//使用valarray类模板记录分数
pubic:
    student():name("Null student"),scores(){}
    explict student(int n):name("Nully"),scores(n){}    //explict阻止隐式转换
    explict student(const std::string&s):name(s),scores(){}    //注意名称空间
    ...
}

        上述类将数据成员声明为私有，这意味着student类的成员函数可以使用string类和valarray类的公有接口（对应对象调用）来访问和修改name和score对象。注意区分继承和包含的列表初始化，继承使用类名调用对应的基类构造函数，包含则使用成员名进行初始化

hasDMA::hasDMA(cosnt hasDMA&hs):baseDMA(hs){}//继承，使用基类类名

explict student(const std::string&s):name(s),scores(){}//包含，使用成员名
//这里scores()可以省去，自动调用默认构造函数

 注：列表初始化的顺序不是列表的顺序，而是数据被声明的顺序。

        同样也可以使用私有继承来实现上述功能。使用私有继承，基类的公有方法将成为派生类的私有方法。

class student:private std::string,private std::valarray<double>
{
private:
    typedef std::valarray<double> ADb;
public:
    student():std::string("Null student"){}
    explict student(int n):std::string("Nully"),ADb(n){}
    explict student(const std::string&s):std::string(s),ADb(){}//使用类名初始化，即调用基类构造函数
    ...
}

         包含时将使用对象名来调用方法，而使用私有继承时将使用类名和作用域解析运算符来调用方法。

double student::average() const
{
    if(scores.size()>0)
        return scores.sum()/scores.size();
    else
        return 0;
}//包含
double student::average() const
{
    if(ADb::size()>0)
        return ADb::sum()/ADb::size();
    else
        return 0;
}//私有继承

        访问基类对象可以通过使用强制类型转换来实现

const string&student::Name() const
{
    return (const string&) *this;
}
ostream & operator<<(ostream & os,const student&stu)
{
    oa<<"scores for"<<(const string&)stu<<"\n";    //强制类型转换，调用string的友元函数
}

         注意，在私有继承中，未进行显式类型转换的派生类引用或指针，无法赋值给基类的引用或指针。但该例中即使是公有继承也需要显式类型转换，因为这里使用了多重继承，编译器无法确定应转换为哪个基类。

使用包含还是私有继承

        包含和私有继承都可以实现has-a关系，那么改如何选择呢？大多C++程序倾向于使用包含，因为它更加易于理解且能包含多个同类的子对象。但如果涉及到访问类的保护成员或重新定义虚函数，应选择使用私有继承。

保护继承

         保护继承是私有继承的变体。使用保护继承时，基类的公有成员和保护成员都将成为派生类的保护成员。保护成员在类中访问权限与私有成员相同，但在继承中，基类的保护成员可以被派生类直接访问。

class student:protected std::string,protected std::valarray<double>
{
...
};

         所以使用私有继承时，第三代类不能使用基类的接口，因为基类的公有和保护成员成为了第二代类的私有成员。而使用保护继承时，第三代类可以使用基类的接口，因为基类的公有成员和保护成员都成为了第二代类的保护成员。

        下面对三种继承方式做一个总结

各种继承方式

特征	公有继承	保护继承	私有继承
公有成员变成	派生类的公有成员	派生类的保护成员	派生类的私有成员
保护成员变成	派生类的保护成员	派生类的保护成员	派生类的私有成员
私有成员变成	只能通过基类接口访问	只能通过基类接口访问	只能通过基类接口访问
能否隐式向上转换	是	是（但只能在派生类中）	否

使用using重新定义访问权限

        使用保护继承或是私有继承时，如果想要基类的方法在派生类外可用有两种方法。第一种是定义一个使用该基类方法的派生类方法

double student::sum() const
{
    return std::valarray<double>::sum();
}//使用私有继承方法

        第二种则是将函数调用包装在另一个函数调用中，即使用using声明来指出派生类可以使用特定的基类成员，即使采用的是基类派生。

class student::private std::string,private std::valarray<double>
{
...
public:
    using std::valarray<double>::min;
    using std::valarray<double>::max;
    using std::valarray<double>::operator[];
...
};

        上述using语句使得min()，max()函数以及重载运算符[ ]可用。使用using声明时只使用函数名（即不包括圆括号，特征标和返回类型）。