C++ imperfect -- 外部直接调用子类private函数

C++的private成员函数限制被外部调用, 但如果想调用子类的private成员函数, 除了使用friend方法, 以下是另外一种方法: 使用多态的继承体系结构.

#include <iostream>
using namespace std;
#define INHERIT_SUB
#ifdef INHERIT_SUB
class Superclass
{
public:
 void test()
 {
  int delay = 0;
  delay = delay;
  PolymorphismFun();
  this->PolymorphismFun();
 }
protected:
 virtual void PolymorphismFun()
 {
  int delay = 0;
  delay = delay;
#pragma message("Superclass::PolymorphismFun")
  cout<<"Superclass::PolymorphismFun"<<endl;
 }
 virtual ~Superclass()
 {
  int delay = 0;
  delay = delay;
 }
};
class SubclassA : public Superclass
{
public:
 void test()
 {
  int delay = 0;
  delay = delay;
  PolymorphismFun();
  this->PolymorphismFun();
 }

 void PolymorphismFun()
 {
  int delay = 0;
  delay = delay;
#pragma message("SubclassA::PolymorphismFun")
  cout<<"SubclassA::PolymorphismFun"<<endl;
 }

 virtual ~SubclassA()
 {
  int delay = 0;
  delay = delay;
 }
};
class SubclassB : public SubclassA
{
public:
 void test()
 {
  int delay = 0;
  delay = delay;
  PolymorphismFun();
  this->PolymorphismFun();
 }
private:
 virtual void PolymorphismFun()=0;
public:
 virtual void operator()()
 {
  int delay = 0;
  delay = delay;
 };
 virtual ~SubclassB()
 {
  int delay = 0;
  delay = delay;
 }
};

class SubclassC : public SubclassB
{
public:
 void test()
 {
  int delay = 0;
  delay = delay;
  PolymorphismFun();
  this->PolymorphismFun();
 }
private:
 void PolymorphismFun()
 {
  int delay = 0;
  delay = delay;
#pragma message("SubclassC::PolymorphismFun")
  cout<<"SubclassC::PolymorphismFun"<<endl;
 }
public:
 virtual void operator()()
 {
  int delay = 0;
  delay = delay;
 };
 virtual ~SubclassC()
 {
  int delay = 0;
  delay = delay;
 }
};
#endif//INHERIT_SUB

int main(int argc, char *argv[])
{
#pragma message("main starting")
#ifdef INHERIT_SUB
 SubclassC testSubclassC;
 testSubclassC.SubclassB::test();
 int nSize = sizeof(testSubclassC);
 Superclass * pSuperclass = &testSubclassC;
 SubclassA *pSubclassA = &testSubclassC;
 SubclassB *pSubclassB = &testSubclassC;
 pSubclassA->PolymorphismFun();// call SubclassC::PolymorphismFun()
 //pSubclassB->PolymorphismFun();//this is not work
 //pSuperclass->PolymorphismFun();// this is not work
#endif //INHERIT_SUB
 return true;
}

在VS2005和cygwin上输出都是

SubclassC::PolymorphismFun
SubclassC::PolymorphismFun
SubclassC::PolymorphismFun

其中, 1,2是由testSubclassC.SubclassB::test()调用输出的; 3是由pSubclassA->PolymorphismFun()调用输出.证明外部调用了子类的private方法. 需要注意的是SubclassA的PolymorphismFun函数是public的，类继承使用public方式,使用其他继承方式同样会发生相应的变化, 如

#include <iostream>

using namespace std;

#define INHERIT_SUB

#ifdef INHERIT_SUB
class Superclass
{
public:
    void test()
    {
        int delay = 0;
        delay = delay;
        PolymorphismFun();
        this->PolymorphismFun();
    }

protected:
    virtual void PolymorphismFun()
    {
        int delay = 0;
        delay = delay;
#pragma message("Superclass::PolymorphismFun")
        cout<<"Superclass::PolymorphismFun"<<endl;
    }

    virtual ~Superclass()
    {
        int delay = 0;
        delay = delay;
    }

};

class SubclassA : private Superclass// change from pulic to private
{
public:
    void test()
    {
        int delay = 0;
        delay = delay;
        PolymorphismFun();
        this->PolymorphismFun();
    }

    void PolymorphismFun()
    {
        int delay = 0;
        delay = delay;
#pragma message("SubclassA::PolymorphismFun")
        cout<<"SubclassA::PolymorphismFun"<<endl;
    }

    virtual void operator()(){
        int delay = 0;
        delay = delay;
    };

    virtual ~SubclassA()
    {
        int delay = 0;
        delay = delay;
    }
};

class SubclassB : public SubclassA
{
public:
    void test()
    {
        int delay = 0;
        delay = delay;
        PolymorphismFun();
        this->PolymorphismFun();
    }

private:
    virtual void PolymorphismFun()=0;

public:
    virtual void operator()()
    {
        int delay = 0;
        delay = delay;
    };

    virtual ~SubclassB()
    {
        int delay = 0;
        delay = delay;
    }
};


class SubclassC : public SubclassB
{
public:
    void test()
    {
        int delay = 0;
        delay = delay;
        PolymorphismFun();
        this->PolymorphismFun();
    }

private:
    void PolymorphismFun()
    {
        int delay = 0;
        delay = delay;
#pragma message("SubclassC::PolymorphismFun")
        cout<<"SubclassC::PolymorphismFun"<<endl;
    }

public:
    virtual void operator()()
    {
        int delay = 0;
        delay = delay;
    };

    virtual ~SubclassC()
    {
        int delay = 0;
        delay = delay;
    }
};
#endif//INHERIT_SUB


int main(int argc, char *argv[])
{
#pragma message("main starting")

#ifdef INHERIT_SUB
    SubclassC testSubclassC;
    testSubclassC.SubclassB::test();
    int nSize = sizeof(testSubclassC);
//    Superclass * pSuperclass = &testSubclassC;// this is not work
    SubclassA *pSubclassA = &testSubclassC;
    SubclassB *pSubclassB = &testSubclassC;
    pSubclassA->PolymorphismFun();
    //pSubclassB->PolymorphismFun();// this is not work
    //pSuperclass->PolymorphismFun();// this is not work
#endif //INHERIT_SUB

    return true;
}

将输出同样的结果.

SubclassC::PolymorphismFun
SubclassC::PolymorphismFun
SubclassC::PolymorphismFun

这种继承调用体系可以让我们实现当存在用户定义行为时, 让用户继承并实现SubclassC类, 否则就调用默认SubClassA类, SubClassB作为接口,提供给用户继承并要求用户实现相应的接口(不管是private、public、protected都可以被调用). 这种方式可以减少if-else的判断,是模式NULL Object的可选实现方法.