C++私有继承

概述

除了在类中直接声明成员变量外，C++还有另一种实现has-a关系的途径——私有继承。使用私有继承，基类的公有成员和保护成员都将成为派生类的私有成员。这意味着基类方法将不会成为派生类对象公有接口的一部分，但可以在派生类的成员函数中使用它们。下面是私有继承的一个示例：

#include <iostream>
#include <string>
#include <vector>
#include <initializer_list>
using namespace std;

class Student : private string, private vector<double> {        //私有继承，使用private关键字
private:
    ostream & pr_grades(ostream &os) const;
public:
    Student() : string("NULL"), vector<double>() {}
    explicit Student(const string &s) : string(s), vector<double>() {}
    Student(const string &s, const vector<double> &v) : string(s), vector<double>(v) {}
    ~Student() {}
    double average() const;
    double & operator[](int i);
    double operator[](int i) const;
    const string & name() const;
    friend istream & operator>>(istream &is, Student &stu);
    friend ostream & operator<<(ostream &os, const Student &stu);
};

ostream & Student::pr_grades(ostream &os) const
{
    int size = vector<double>::size();
    for (int i = 0; i < size; ++i)
        os << vector<double>::at(i) << ", ";
    os << endl;
}

double Student::average() const
{
    if (vector<double>::empty())        //访问基类的方法，直接使用类名和作用域解析运算符
        return 0;
    double sum = 0;
    for (int i = 0; i < vector<double>::size(); ++i)
        sum += vector<double>::at(i);
    return sum / vector<double>::size();
}

double & Student::operator[](int i)
{
    return vector<double>::at(i);
}

double Student::operator[](int i) const
{
    return vector<double>::at(i);
}

const string & Student::name() const
{
    return (const string &)*this;       //访问基类的成员，使用强制转换
}

istream & operator>>(istream &is, Student &stu)
{
    is >> (string &)stu;
    return is;
}

ostream & operator<<(ostream &os, const Student &stu)
{
    os << (const string &)stu << ": ";
    stu.pr_grades(os);
}

int main()
{
    vector<double> grades{90, 91, 92, 93};
    Student stu("Tony", grades);
    cout << "修改学生姓名：";
    cin >> stu;
    cout << "第一门成绩：" << stu[0] << endl;
    cout << "平均成绩：" << stu.average() << endl;
    cout << stu;
    return 0;
}

输出：

修改学生姓名：Tom
第一门成绩：90
平均成绩：91.5
Tom: 90, 91, 92, 93,

Student类私有继承自string和vector<double>类，可以理解为Student类有一个string和vector<double>对象，如果要使用包含，则可以直接声明成员变量

private:
    string name;
    vector<double> grades;

与public继承不同的是，如果classes之间的继承关系是private，编译器不会自动将一个派生类对象（例如Student）转换为一个基类对象（例如string）

访问基类的方法

使用私有继承时将使用类名和作用域解析运算符来调用基类的方法

double Student::average() const
{
    if (vector<double>::empty())        //访问基类的方法，直接使用类名和作用域解析运算符
        return 0;
    double sum = 0;
    for (int i = 0; i < vector<double>::size(); ++i)
        sum += vector<double>::at(i);
    return sum / vector<double>::size();
}

访问基类对象

使用强制转换，为避免调用构造函数创建新的对象，可使用强制类型转换来创建一个引用

const string & Student::name() const
{
    return (const string &)*this;       //访问基类的成员，使用强制转换
}

访问基类的友元函数

用类名显示地限定函数名不适合于友元函数，这是因为友元不属于类。然而，可以通过显示地转换为基类来调用正确的函数。

ostream & operator<<(ostream &os, const Student &stu)
{
    os << (const string &)stu << ": ";
    ......
}

使用包含还是私有继承

通常，应使用包含来建立has-a关系；如果新类需要访问原有类的保护成员，或需要重新定义虚函数，则应使用私有继承。