C++還有另一種實現(xiàn)has-a關系的途徑——私有繼承。（上一個是包含）

1. 使用私有繼承，基類的公有方法將成為派生類的私有方法。派生類不繼承基類接口。
2. 使用私有繼承，類將繼承實現(xiàn)。比如從string類派生Student類，Student類可以使用string組件，可用于保存字符串。Student類可以用string方法訪問string組件
3. 包含將對象作為一個命名成員添加到類中，私有繼承將對象作為未命名的繼承對象添加到類中。
4. 用關鍵字private來聲明類

類聲明
#include<iostream> 
#include<valarray>
#include<string>
using std::string;
class Student:private string, private std::valarray<double>
{
    private:
        typedef std::valarray<double> AR;
        std::ostream& arr_out(std::ostream& os) const;
    public:
        Student() : string("No"),AR(){}
        explicit Student(const string& s):string(s),AR() {}
        explicit Student(int n): string("Jeff"),AR(n){}
        Student(const string& s,int n):string(s),AR(n){}
        Student(const char* str,const double* pd, int n)
        :string(str),AR(pd,n){}
        ~Student(){}
        double average() const;
        const std::string& Name() const;
        double& operator[](int i);
        double operator[](int i) const;
        friend std::istream& operator>>(std::istream& is,Student& s);
        friend std::istream& getline(std::istream& is,Student& s);
        friend std::ostream& operator<<(std::ostream& os,const Student& s);
};

1. 包含中private部分有string命名對象和valarray命名對象，私有繼承不用這些對象，而是用類組件代替。
2. 包含中構造函數(shù)用對象名來初始化，私有繼承使用類名來初始化。(內聯(lián)構造函數(shù))

#include"studentc.h"
using std::cout; 
std::ostream& Student::arr_out(std::ostream& os) const
{
    int i;
    int lim=AR::size();
    if(lim>0)
    {
        for(i=0;i<lim;i++)
        {
            os<<AR::operator[](i)<<" ";
            if(i%5==4)
                os<<std::endl;
        }
        if(i%5!=0)
            os<<std::endl;
    }
    else
        os<<"empty scores ";
    return os;
}

double Student::average() const
{
    if(AR::size()!=0)
        return AR::sum()/AR::size();
    else
        return 0; 
}

const std::string& Student::Name() const
{
    return (const string&) *this;
}

double& Student::operator[](int i)
{
    return AR::operator[](i);
}

double Student::operator[](int i) const
{
    return AR::operator[](i);
}



std::istream& operator>>(std::istream& is,Student& s)
{
    is>>(string& )s;
    return is;
}

std::istream& getline(std::istream& is,Student& s)
{

    for(int i=0;i<s.AR::size();i++)
        is>>s.AR::operator[](i);
    return is;
}

std::ostream& operator<<(std::ostream& os,const Student& s)
{
    os<<"Scores for "<<(const string&)s<<": ";
    s.arr_out(os);
    return os;
}

1. 訪問基類方法：
   AD::size()這樣，用類名和作用域解析運算符來調用基類方法.
   s.AD::size()該基類方法變成Student私有方法
   AD::operator[](i) 調用函數(shù)
2. 訪問基類對象
   用強制類型轉換
   （const string&) *this
3. 訪問友元函數(shù)
   顯示類型轉換

使用包含還是私有繼承？

1. 大部分都會傾向于使用包含，易于理解，因為可以使用顯式命名對象。使用繼承關系會更抽象。
2. 繼承會引起很多問題，尤其是從多個基類繼承時（叫多重繼承）
3. 包含能夠包括多個同類的子對象，而繼承則只能使用一個這樣的對象。
4. 私有繼承提供的特性會比包含多，比如包含是不能訪問保護對象的，但是私有繼承可以，因為私有繼承派生出類，而包含不是派生類。（需要使用私有繼承）
5. 另一種需要使用私有繼承的是需要重新定義虛函數(shù)。

保護繼承

保護繼承是私有繼承的變體，在列出基類時使用protected

1. 在使用保護繼承時，基類的公有成員和保護成員將成為派生類的保護成員。且基類接口也可以在派生類中使用，跟私有繼承一樣。
2. 當派生類派生出另一個類。使用私有繼承時，第三代類將不能使用基類的接口，因為基類的公有方法會變成派生類的私有方法。但是使用保護繼承就可以使用。

using重新定義訪問權限

如果要使基類的方法在派生類外使用：

1. 定義一個使用該基類的派生類方法

double Student::sum() const
{  return std::valarray<double>::sum() }

2. 將函數(shù)調用包裝到另一個函數(shù)調用中，使用using聲明

public:
   using std::valarray<double>::max;
    using std::valarray<double>::operator[];

using聲明只使用成員名，且只適合繼承。

cout<<ada[i].max<<endl；