如果声明虚函数声明为private时编译会报错，但是还是有手段调用声明为private的虚函数的。首先让我们来看看调用声明为private的虚函数时会发生什么情况。

#include <iostream>

using namespace std;
class classB
{
private:
	virtual void fun() { cout << "virtual fun of classB" << endl; }
	void fun2() { cout << "fun2 of classB" << endl; }
	//friend int main();
};

class classA : public classB
{
public:
	virtual void fun() { cout << "virtual fun of classA" << endl; }
	void fun2() { cout << "fun2 of classA" << endl; }


};


int main()
{
	classB *obj = new classA;
	obj->fun();
	obj->fun2();
	while (1);

	return 0;
}

那么如何能把虚函数声明为private呢，把要调用该虚函数的函数声明为类的友元函数就行了，让我们看一下。

#include <iostream>

using namespace std;
class classB
{
private:
	virtual void fun() { cout << "virtual fun of classB" << endl; }
	void fun2() { cout << "fun2 of classB" << endl; }
	friend int main();
};

class classA : public classB
{
public:
	virtual void fun() { cout << "virtual fun of classA" << endl; }
	void fun2() { cout << "fun2 of classA" << endl; }


};


int main()
{
	classB *obj = new classA;
	obj->fun();
	obj->fun2();
	while (1);

	return 0;
}

可以看到当classA中的虚函数为public是可以这样调用的，但是如果classA中的虚函数声明为private还可以调用吗？让我们来看一下。

#include <iostream>

using namespace std;
class classB
{
private:
	virtual void fun() { cout << "virtual fun of classB" << endl; }
	void fun2() { cout << "fun2 of classB" << endl; }
	friend int main();
};

class classA : public classB
{
public:
	
	void fun2() { cout << "fun2 of classA" << endl; }
private:
	virtual void fun() { cout << "virtual fun of classA" << endl; }

};


int main()
{
	classB *obj = new classA;
	obj->fun();
	obj->fun2();
	while (1);

	return 0;
}

可以看到即使classA中的虚函数声明为private时还是可以调用的，这是为什么呢？main又不是classA的友元函数，我个人观点是虚函数是实际上通过classB对象来调用的，如果理解有错麻烦告诉我一下，谢谢！

一般我们说虚函数，它的访问级别都是public的，用类对象可以直接调用，这样就可以实现运行时的类型绑定，那如果我们将虚函数私有化会出现什么情况呢？

我们先来看一个非虚函数私有化的例子

class Base
{
private:
    void PrintClassName ()
    {
        cout<<"Base"<<endl;
    }
public:
    void print()
    {
        PrintClassName();
    }
};

class Derived : public Base
{
private:
    void PrintClassName()
    {
        cout<<"Derived"<<endl;
    }
};

在main函数里产生一个Derived的对象d，然后调用print()函数，即d.print()，结果输出的却是Base，print()函数没有调用子类的PrintClassName函数，而是调用父类的PrintClassName函数，原来是由于PrintClassName函数不是虚函数之故，所以Base的print()函数调用PrintClassName()函数是在编译时就已经绑定了，而不是运行期绑定。

下面我们让PrintClassName()函数变成虚函数再执行，就可以看到输出的类名为子类的名称，即Derived。

那么我们有没有办法调用私有的虚函数呢？当然是有的，不管公有还是私有，只要是虚函数，它的函数地址都会放在虚函数表vftable中，只要我们找到虚函数表中存放的PrintClassName()函数的地址，我们就可以直接调用，前提是你必须对C++类对象的内存布局要熟悉，代码如下，这样也输出Derived，与前面效果相同

int _tmain(int argc, _TCHAR* argv[])
{
    
    Derived d;
    //d.print();
    typedef void (*Fun)();
    Fun pFun = NULL;
    pFun = (Fun)*((int *)(*(int *)&d + 0) + 0);
    pFun();

    getchar();
    return 0;
}

本文目的

 
  前些天面试，被问到一个很有意思的问题：c++中能否直接调用protected修饰的虚函数，之前没有尝试过，所以只能靠直觉回答：“在技术上，只要知道虚函数表的地址就可以调用，但是不清楚protected保护的机制是具体在哪一个时期起的作用，可能需要一些手段来绕开这个机制。” 我的回答就是这样（自我感觉回答的还是含糊不清楚，只是概念上推测，没有给出具体的方法）。好心的面试官还是跟我解释了protected是编译器在编译期做检查。所以本文就直接上代码，给出解决此问题的具体的实现。
（ps：对虚函数表内部结构不明白的可以看我的另一篇文章，C++在gcc下的单继承，多继承，虚继承的内存布局）

代码

不可行的直接调用

	    1 #include<iostream>                                                        
    2 
    3 using namespace std;
    4 
    5 typedef void (*Fuc)(void);
    6 
    7 class A{
    8 protected:
    9     virtual void foo()
   10     {
   11         cout<<"A foo"<<endl;
   12     }
   13 private:
   14     virtual void bar()
   15     {
   16         cout<<"A bar"<<endl;
   17     }
   18 };
   19 
   20 int main()
   21 {
   22     A* a = new A; 
   23     a->foo();
   24     a->bar();
   25 }

结果：

意料之内的编译错误。

可行的指针调用

  1 #include<iostream>
  2 
  3 using namespace std;
  4 
  5 typedef void (*Fuc)(void);
  6 
  7 class A{
  8 protected:
  9     virtual void foo()
 10     {
 11         cout<<"A foo"<<endl;
 12     }
 13 private:
 14     virtual void bar()
 15     {
 16         cout<<"A bar"<<endl;
 17     }
 18 };
 19 
 20 int main()
 21 {
 22     A* a = new A; 
 23     Fuc fucFoo = (Fuc)*((long*)*(long*)a);
 24     Fuc fucBar = (Fuc)*((long*)*(long*)a+1);
 25     fucFoo();
 26     fucBar();
 27 }      

运行结果：

  成功运行，且没有触发编译器的检查（因为就没有调用A的对象，单纯根据虚函数地址通过函数指针调用）。
（ps：对虚函数表内部结构不明白的可以看我的另一篇文章，C++在gcc下的单继承，多继承，虚继承的内存布局）

尾语

  不明白就得动手，不然只能原地打转，处于被动。

以上