明明白白c++ 虚函数和多态性-优快云博客

本文链接：https://blog.youkuaiyun.com/mlkiller/article/details/8852200

纸上得来终觉浅，绝知此事要躬行。

本文的目的，一方面是作者本人希望通过写文章来弄清楚虚函数和多态性，另一方面，也希望读者可以自己练习练习，不写代码，不编程序，只看别人的代码和文章很难把知识转换为自己的。大家一起加油。

一概念

多态性是面向对象(OOP)语言的一个共有的特性。

OOP 语言的三大特性：封装，继承和多态。下面文章讲述的很好，很干练。我就不班门弄斧了。

http://www.cnitblog.com/Lily/archive/2013/01/03/6860.html

多态的意思就是不同的对象，接受到同一消息的时候，产生不同的动作。

举个例子来说，比如狗，鸟，鱼，人都属于生物这一类，如果发生地震了，他们都接受了逃命这个消息，狗会四条腿的跑走，鸟会飞走，鱼会游走，人则是两条腿的跑走。

我们可以认为这个就是一个多态的例子。

可以参考下面文章的含义

http://blog.youkuaiyun.com/livelylittlefish/article/details/2171445

不好意思以前这里写错了~~（讲的很清楚，多态有两种C++，一种是覆盖，编译的时候确定，静态绑定，一种是重载，运行的时候确定，动态绑定。）~~

后来理解了一下，多态c++有两种，一种是静态绑定，例如重载，另外一种是动态绑定,带有virtual关键字的。

c++ primer里面有句话，在编译的时候确定非virtual的函数

重载，我这里就不说了，就是函数的参数表不一样。

二隐藏

这个其实很好理解，类似于全局变量和局部变量，那么局部变量就会隐藏全局变量。

局部函数和全局函数，局部函数的概念这里指 static函数。

看下面一段代码

在static.cpp里面定义了一个print.

#include <iostream>
using namespace std;
static void print()
{
   cout<<"static"<<endl;
}

void callstatic()
{
  print();
}

在global.cpp里面定义另一个print

#include <iostream>
using namespace std;

void print()
{
   cout<<"global"<<endl;
}

extern void callstatic();
int main()
{
    callstatic();
	print();
}

程序输出的结果是:

static

global

程序很简单，说一下需要注意的地方：

1 如果static.cpp里面不加入关键字static在print函数前面，编译的时候会报链接错误。

c/c++里面不是在类里面的函数，不加关键字static就是全局函数，所有有两个全局函数，连接器就会报错。

static保证函数只是在此文件中使用。

2 extern这个关键字，对于函数是可有可无的，都表示函数声明。

它会去找函数的定义，在连接的时候，上面和这个结合起来，大家就明白为什么要static来表示函数了。

但是extern在对全局变量声明的时候，必须用。（ps:后面我会写一下，声明，定义，初始化三个之间的关系，对于初学者就不至于稀里糊涂了）

3 我联想到全局变量，局部变量，静态变量三者直接的关系，也放在后面的文章写吧。（太多容易混淆了，写文章的时候，发现处处机关，处处学问。）

而类的隐藏和这里的隐藏应该是一个意思

类里面的隐藏，废话少说了，代码为证。

#include <iostream>
using namespace std;

class A
{
public:
   void print()
   {
       cout <<"class A"<<endl;
   }
};

class B:public A
{
public:
    void print()
	{
	    cout <<"class B"<<endl;
    }
	
};

int main()
{
        A a;
	A *pA;
	B b;
	B *pB;
        cout<<sizeof(A)<<" "<<sizeof(B)<<endl;
        a.print();
        b.print();
        pA = &a;pA->print();

        pA = &b;pA->print();
        //pB = &a; 从类型‘A*’到类型‘B*’的转换无效
     //pB->print();
     pB = &b;
   pB->print();
}

结果为：

1 1

class A

class B

class A

class B

有几个需要注意的：

1 class B:public class A 这个public不能少，一旦少了，变成了私有继承，那么pA = &b就会报错，错误：‘A’是‘B’不可访问的基类

这里解释一下，pA指向&b，其实就是指向b继承的a部分，如果这部分是私有的话，那么指针自然无法访问。画图比较麻烦，如果不了解的话可以评论里面回复，我会解答，或者补发一下图文，不然就当理解了。

2 如果class B: private class A 这个时候，那么在class B里面会有两个print,一个是继承A的私有的，另一个自己的。

我自己做了一下测试，总结一下隐藏的意思并不是说父类里面的函数没有了，调用函数的类指针，对象，引用的类型决定了调用哪个函数？指针，对象或者引用是A则调用A，是B则调用B, 。另外其实私有继承或者方法是私有的，隐藏本身意义不大，不用太去深究，因为外部无法调用。

我觉得隐藏更多是出于兼容c的语法，而不是为了设计的多样性，这样很容易混淆，而且实际应用价值不是很大。

所以在java里面不存在的隐藏，因为java本身没有指针，这样就没有意义。

写这么多只是表面隐藏的语法，至于其实际应用价值，我认为没有。反而觉得利大于弊。

三覆盖，或者重写(ovrride) （虚函数）

覆盖和隐藏的共同点是：

函数名字，函数参数必须一样。

不同点是：

关键字 virtual是否存在。

虚函数，以前我看到这个就头疼，觉得乱七八糟的，而且觉得c++设计的太乱了，又要兼容c，又要面向对象，规则细节一大堆。

光类的初始化之类的都一大堆，导致我每次还没有看到虚函数，就放弃了。终于鼓起勇气好好写一下了。

大家可以看一下java和c++的对比http://blog.youkuaiyun.com/fuxingwe/article/details/8849028还有http://www.cnblogs.com/harryguo/archive/2008/06/16/1222976.html

写了下java里面的多态性的实现，可以看到java就完全摒弃了隐藏，这样看起来更加舒服点。

#include <iostream>
using namespace std;

class A
{
public:
   void print()
   {
       cout <<"class A"<<endl;
   }
   virtual void vrPrint()
   {
		cout <<"class A vr"<<endl;
   }
};

class B:public A
{
public:
    void print()
	{
	    cout <<"class B"<<endl;
    }
	virtual void vrPrint()
    {
		cout <<"class B vr"<<endl;
    }
	
};


int main()
{
    A a;
	A *pA;
	B b;
	B *pB;

	cout<<sizeof(A)<<" "<<sizeof(B)<<endl;
	a.vrPrint();
	b.vrPrint();
	pA = &a;
	pA->vrPrint();
	pA = &b;
	pA->vrPrint();
	pB = &b;
	pB->vrPrint();
}

输出结果是：
4 4
class A vr
class B vr
class A vr
class B vr
class B vr
有两个变化
1 类大小变了，上面的大小是1，而这里是4，
2 pA = &b 时候， pA的打印变了。
看一下这个时候pa的虚函数表