私有继承基类函数如何被访问

　　C++面向对象中的继承模式有三种：公有继承(关键字public)、保护继承(关键字protected)和私有继承(关键字private)。在开发中以公有继承占绝大多数情况，保护和私继承使用情况很少。写这篇博客介绍私有继承，源于一个问题。下面给大家详细道来。

一、限制C++接口问题

　　有一个Rectangle类，它向外界提供了三个接口，类定义如下：

struct Position
{
    int x;
    int y;
};

class Rectangle
{
public:
    explicit Rectangle(const Position& pos, int w, int h)
        : _pos(pos)
        , _w(w)
        , _h(h)
    {}
    int GetWidth() const { return _w; }
    int GetHeight() const { return _h; }
    void Draw()
    {
        std::cout << "Rectangle::Draw()
";
    }
private:
    Position _pos;
    int _w;
    int _h;
};

　　现在，我希望编写一个新的类，只让他有Draw的能力。该怎么办？实现的方式多种多样，但是我们用继承的方式实现这个需求。

二、继承如何限制C++接口

　　我们知道C++面向对象中的基础有三种模式，其中公有继承不改变基类的访问属性，所以无法起到限制上面GetWidth和GetHeight接口。保护继承和私有继承都可以限制基类的公共接口被外部直接访问；保护和私有的区别在于，保护的方法可以被子类访问，私有的方法不行。保护和私有继承都可以限制C++接口的能力。代码如下：

class DrawableRectangle : protected Rectangle
{
public:
    explicit DrawableRectangle(const Rectangle& rect)
        : Rectangle(rect)
    {}
};

int main()
{
    Rectangle rect(Position{ 0, 0 }, 10, 10);
    DrawableRectangle drawableRect(rect);
    drawableRect.Draw();
}

　　或者

class DrawableRectangle : private Rectangle
{
public:
    explicit DrawableRectangle(const Rectangle& rect)
        : Rectangle(rect)
    {}
};

int main()
{
    Rectangle rect(Position{ 0, 0 }, 10, 10);
    DrawableRectangle drawableRect(rect);
    drawableRect.Draw();
}

　　当同学们兴致勃勃地编写上面的代码，点击编译的时候，突然发现：

       

　　或 

　　

　　发现编译根本无法正常通过。这样写确实无法正常通过的，这边“坑爹”吗？有的同学马上想到了友元类可以解决这个问题，于是敲动键盘写下如下代码：

class DrawableRectangle : private Rectangle
{
public:
    explicit DrawableRectangle(const Rectangle& rect)
        : Rectangle(rect)
    {}

    friend class Client;
};

class Client
{
public:
    void Test()
    {
        Rectangle rect(Position{ 0, 0 }, 10, 10);
        DrawableRectangle drawableRect(rect);
        drawableRect.Draw();
    }
};

int main()
{
    Client t;
    t.Test();
}

　　恭喜你，这样确实能起到限制C++接口的同时，能够访问基类的接口。编译并运行的结构如下： 

      

 　　但是你却忽略了友元的弊端，破坏封装性，友元确实能够访问类的保护和私有方法或属性，这里是所有哦！例如我还是可以正常访问GetWidth和GetHeight方法：

class Client
{
public:
    void Test()
    {
        Rectangle rect(Position{ 0, 0 }, 10, 10);
        DrawableRectangle drawableRect(rect);
        drawableRect.Draw();
        std::cout << "width<" << drawableRect.GetHeight() 
            << "> height<" << drawableRect.GetHeight() << "
";

    }
};

int main()
{
    Client t;
    t.Test();
}

　　

 　　绕这么大的弯子，还是没有解决我之前提到的问题。是不是这个问题根本就不能用继承解决？

三、using关键字

　　刚开始我也这么认为，但是直到看到如下代码：

class DrawableRectangle : private Rectangle
{
public:
    explicit DrawableRectangle(const Rectangle& rect)
        : Rectangle(rect)
    {}

    using Rectangle::Draw;
};
int main()
{
    Rectangle rect(Position{ 0, 0 }, 10, 10);
    DrawableRectangle drawableRect(rect);
    drawableRect.Draw();
    drawableRect.GetWidth();
    drawableRect.GetHeight();
}

　　

　　编译只报GetWidth和GetHeight接口不可访问的错误，并没有报Draw接口。我们屏蔽掉报错的接口，再次编译后运行：

       

　　保护或私有继承的子类中，使用这个using关键字指定基类某个方法或属性都可以在外界通过子类自己调用吗？

　　基类方法或属性是public：

class Rectangle
{
public:
    explicit Rectangle(const Position& pos, int w, int h)
        : _pos(pos)
        , _w(w)
        , _h(h)
    {}
    int GetWidth() const { return _w; }
    int GetHeight() const { return _h; }
    void Draw()
    {
        std::cout << "Rectangle::Draw()
";
    }
    int _a;
private:
    Position _pos;
    int _w;
    int _h;
};

class DrawableRectangle : private Rectangle
{
public:
    explicit DrawableRectangle(const Rectangle& rect)
        : Rectangle(rect)
    {}

    using Rectangle::Draw;
    using Rectangle::_a;
};
int main()
{
    Rectangle rect(Position{ 0, 0 }, 10, 10);
    DrawableRectangle drawableRect(rect);
    drawableRect.Draw();
    drawableRect._a = 10;
}

　　

 　　基类方法或属性是protected：

class Rectangle
{
public:
    explicit Rectangle(const Position& pos, int w, int h)
        : _pos(pos)
        , _w(w)
        , _h(h)
    {}
    int GetWidth() const { return _w; }
    int GetHeight() const { return _h; }
    void Draw()
    {
        std::cout << "Rectangle::Draw()
";
    }
    int _a;
protected:
    void Fn()
    {
        std::cout << "Rectangle::Fn() protected
";
    }
    int _b;
private:
    Position _pos;
    int _w;
    int _h;
};

class DrawableRectangle : private Rectangle
{
public:
    explicit DrawableRectangle(const Rectangle& rect)
        : Rectangle(rect)
    {}

    using Rectangle::Draw;
    using Rectangle::_a;
    using Rectangle::Fn;
    using Rectangle::_b;
};
int main()
{
    Rectangle rect(Position{ 0, 0 }, 10, 10);
    DrawableRectangle drawableRect(rect);
    drawableRect.Fn();
    drawableRect._b = 10;

}

　　

　　基类方法或属性是private：

class Rectangle
{
public:
    explicit Rectangle(const Position& pos, int w, int h)
        : _pos(pos)
        , _w(w)
        , _h(h)
    {}
    int GetWidth() const { return _w; }
    int GetHeight() const { return _h; }
    void Draw()
    {
        std::cout << "Rectangle::Draw()
";
    }
    int _a;
protected:
    void Fn()
    {
        std::cout << "Rectangle::Fn() protected
";
    }
    int _b;
private:
    void Fn1()
    {
    }
private:
    Position _pos;
    int _w;
    int _h;
};

class DrawableRectangle : private Rectangle
{
public:
    explicit DrawableRectangle(const Rectangle& rect)
        : Rectangle(rect)
    {}

    using Rectangle::Draw;
    using Rectangle::_a;
    using Rectangle::Fn;
    using Rectangle::_b;

    using Rectangle::Fn1;
    using Rectangle::_w;
};

　　

 　　语法报错，所以说除了private修饰的成员方法和属性外，另外两种都可以通过using关键正常指定外界可以访问的方法或接口。保护继承同私有继承作用类似，这里不再列举处理进行验证。（上面都是通过visual studio2019编译的，对于低版本的，尤其不支持using关键字的编译器就不支持这种用法了）。

　　公用继承下，子类和基类是:is-a的关系，即子类是基类的一种类型。（这里不考虑继承抽象类，子类和抽象类是：has-a关系）私有继承不在让子类和基类拥有：is-a的关系，而是变成：has-a的关系。这种继承模式下，能够起到适当屏蔽基类中的公共方法，到达子类不同于基类的行为的作用。

参考：

1、Restricting an interface in C++ - Fluent C++ (fluentcpp.com)

2、The quest of private inheritance in C++ | Sandor Dargo's Blog