推理:)

Q:
村子中有50个人，每人有一条狗。在这50条狗中有病狗(这种病不会传染)。于是人们就要找出病狗。每个人可以观察其他的49条狗，以判断它们是否生病，只有自己的狗不能看。观察后得到的结果不得交流，也不能通知病狗的主人。主人一旦推算出自己家的是病狗就要枪毙自己的狗，而且每个人只有权利毙自己的狗，没有权利打死其他人的狗。第一天，第二天都没有枪响。到了第三天传来一阵枪声，问有几条病狗，如何推算得出？

A1:
A、假设有1条病狗，病狗的主人会看到其他狗都没有病，那么就知道自己的狗有病，所以第一天晚上就会有枪响。因为没有枪响，说明病狗数大于1。
B、假设有2条病狗，病狗的主人会看到有1条病狗，因为第一天没有听到枪响，是病狗数大于1，所以病狗的主人会知道自己的狗是病狗，因而第二天会有枪响。既然第二天也每有枪响，说明病狗数大于2。
由此推理，如果第三天枪响，则有3条病狗

A2:
1 如果为1，第一天那条狗必死，因为狗主人没看到病狗，但病狗存在。
2 若为2，令病狗主人为a，b。 a看到一条病狗，b也看到一条病狗，但a看到b的病狗没死故知狗数不为1，而其他人没病狗，所以自己的狗必为病狗，故开枪；而b的想法与a一样，故也开枪。
由此，为2时，第一天看后2条狗必死。
3 若为3条，令狗主人为a，b，c。 a第一天看到2条病狗，若a设自己的不是病狗，由推理2，第二天看时，那2条狗没死，故狗数肯定不是2，而其他人没病狗，所以自己的狗必为病狗，故开枪；而b和c的想法与a一样，故也开枪。
由此，为3时，第二天看后3条狗必死。
4 若为4条，令狗主人为a，b，c，d。a第一天看到3条病狗，若a设自己的不是病狗，由推理3，第三天看时，那3条狗没死，故狗数肯定不是3，而其他人没病狗，所以自己的狗必为病狗，故开枪；而b和c，d的想法与a一样，故也开枪。
由此，为4时，第三天看后4条狗必死。
5 余下即为递推了，由年n－1推出n。
答案：n为4。第四天看时，狗已死了，但是在第三天死的，故答案是3条。

12星座与30年后的自己对话

zz from http://www.kaiyuan.de/forum/index.php?showtopic=161446


　岁月悠悠，光阴荏苒，今年的你，已经是在这个美丽世界的第几个年头了？这些年里，你一定变化了不少，成长了许多，以往的童真变成今天的成熟。那么，当我们以回首过去的方式展望未来，若你有机会跟30年后的自己对话，你会跟他说什么呢？

小白羊：“哇，看你的样子混的不错啊，快，借点钱给我，不不，给钱给自己嘛，反正我们俩谁跟谁，以后我就靠你了啊！”

　　老白羊：(劈头盖脸大骂)“你想的倒美啊，那我问谁要去？你未来的老婆花钱大手

大脚你知不知道啊？还有你儿子谁给你养？问未来的自己要钱，亏你想的出来，自己申请信用卡去。”

　　小白羊：(嘀咕)“我那不是信用卡已经透支了嘛……”


　小金牛：“啊呀，你就是我的先知了，跟我说说我的未来吧，我对未来好没有把握哦，我以后会怎样？工作、生活、感情？”

　　老金牛：“都挺好的啊，工作感情生活都很稳定，不过，说真的，回首起来，我还真宁可当初的自己大胆一些，多换换环境，多接触点不同的事情，总是求稳似乎是得不偿失的哦。”

　　小金牛：“真的吗？听上去不错，但是我觉得在一个地方稳定的发展也很好嘛，看你现在的样子还不错，我就更放心啦。”



　　老金牛：“哎，其实这样会错过不少精彩啊。”



小双子：“你真的来自30年后吗？快，把所有的娱乐八卦统统告诉我！张柏芝跟谢霆锋后来怎样了？王菲跟李亚鹏呢？超女后来发展的如何？还有还有……”

　　老双子：“你关心的这些太没价值了，你都不知道30年娱乐圈发展真是天翻地覆啊，我来跟你画个表啊……”

　　小双子：“哇、、真的啊、、哇哇、、我都记下来……”

　　老双子：“你去当个娱乐记者吧，不用跑不用等，直接问我就有爆炸性新闻啦！”



小巨蟹：“哎，快让我看看我的孩子，我的孩子呢？我的孩子是帅哥还是美女啊？！”

　　老巨蟹：“帅哥啦，跟女朋友约会去了，放心，孩子很好，家里都很好，嘿嘿，我跟他说你妈也有年轻的时候，他偏不信，真想带你去见见他，看他妈年轻的时候多漂亮，比他那个女朋友漂亮多了！”

　　小巨蟹：“呵呵……那妈妈还好吗？爸爸身体如何了？奶奶呢……？”

　　老巨蟹：“……”



　小狮子：“看到你精神飒爽的样子，就知道在我的努力下，你混的不错哦！跟我说说我未来的成就吧，我办的企业有没有进世界500强啊，我是不是30年后的焦点名人啊……”

　　老狮子：“看你这小毛孩的样子，你还真以为自己是国王了呢，哎，我当年就是这样啊，后来你就会慢慢知道，浮躁跟自信之间的区别了，傲气成就不了大事，骄兵必败。呵呵，小子，路漫漫啊”

　　小狮子：“哼，反正我只知道，没有我就没有你！”



　小处处：“我总是觉得自己很多事情没有做好，不够完美，你能不能提醒提醒我在今后可能犯的错误？如何在每件事情上做出自己最好的选择，不会犯错？”

　　老处处(此处不可称为老处女哦！)：“看到30年前的自己真是感慨良多，其实，别那么追求完美了，这样很累人的哦，而且会让别人也很累……”

　　小处处：“你不是吧，你不仅不教我，还说我不对？你还是不是我啊，你真的是我吗？我以后会变成你吗？……如果一件事做的不完美，那我还不如不做！”



　　老处处：“等你老了就知道了……”



　小天秤：“啊呀，你是我吗？我用了那么多的化妆品，怎么你还是老成了这个样子啊？！”

　　老天秤：“我老？那还不是怪你，化妆品一大堆，保养品没几样！你用过玫瑰精油吗？你给自己洗过牛奶浴吗？你总是化妆多过保养，贪图一时的美丽……现在皮肤当然老化的快啊！”

　　小天秤：“……天哪，无论如何，看到你我真的不想活了，555555555555”

　　老天秤：“我有那么丑吗？扁你哦！”



小天蝎：“你确定你来自30年之后？”

　　老天蝎：“对啊，能见到年前的自己真开心啊！”

　　小天蝎：“废话少说，赶紧去给我查查，2006年11月的彩票中奖号码，给我短信，咱们后半生的幸福就靠这个了！”

　　老天蝎：“啊……此计甚妙矣！老夫这就去！”



小射手：“我的梦想是去丽江、西藏、天山、昆仑山……你都实现了吗？”

　　老射手：“当然哦！何止呢，我还去了非洲穿越沙漠、南极洲探险、太平洋远航，有一堆好玩的事情呢！”

　　小射手：“哇，我的未来真的那么幸福啊！！快，快跟我讲讲！”

　　老射手：“当然会跟你讲，但是有一点，我希望你学会珍惜感情啊，哎，别漂泊一辈子错过无数好女孩，那个小丽真是不错，这么多年来，都觉得还是她好，可惜啊！”



　　小射手：“不是吧，感伤不是我的风格，先说好玩的再说！”
(-_-)****


小魔羯：“你要努力啊，你这个年龄说老不老，说年轻不年轻，要多存点钱，等真正老了的时候用得上啊！”

　　老魔羯：“努力努力，我都努力一辈子了，现在累得不行，不过不用你提醒，我也知道努力啊，倒是你！年纪轻轻的才是应该努力呢，你给我多学点东西知道不？！现在竞争激烈啊，学习如逆水行舟，不进则退知道不？”

　　小魔羯：“寒啊，怎么跟我妈一个口气”



　小水瓶：“30年后科技已经日新月异了吧，能不能去月球度假，去火星旅游啊，能不能随便飞，有没有任意门啊？”

　　老水瓶：“你当我是机器猫啊？！”

　　小水瓶：“哎，那你把你现在用的那款手机给我吧，至少我能拿去给我朋友们秀秀30年后的新款！”

　　老水瓶：“……寒，那我怎么办，你的手机在我那根本用不了嘛！”



小双鱼：“见到你真是太好了，快告诉我，我后来是不是幸福的跟张三在一起了？”

　　老双鱼：“哎，跟张三只是过眼云烟，你别迷恋他了，你过1年会遇到李四，李四更是风度翩翩的浪漫才子哦，不过，没有缘分啊，之后遇到的王五、赵六……”

　　小双鱼：“啊？我才不要，我要跟张三一生一世！”

　　老双鱼：“孩子啊……你果然是当年的我啊……”

Using the Bessel function, scientists write text on water surface

ZZ from http://www.pinktentacle.com/2006/07/device-uses-waves-to-print-on-water-surface/

Using the Bessel function, scientists write text on water surface

Researchers at Akishima Laboratories (Mitsui Zosen), working in conjunction with professor Shigeru Naito of Osaka University, have developed a device that uses waves to draw text and pictures on the surface of water.

The device, called AMOEBA (Advanced Multiple Organized Experimental Basin), consists of 50 water wave generators encircling a cylindrical tank 1.6 meters in diameter and 30 cm deep (about the size of a backyard kiddie pool). The wave generators move up and down in controlled motions to simultaneously produce a number of cylindrical waves that act as pixels. The pixels, which measure 10 cm in diameter and 4 cm in height, are combined to form lines and shapes. AMOEBA is capable of spelling out the entire roman alphabet, as well as some simple kanji characters. Each letter or picture remains on the water surface only for a moment, but they can be produced in succession on the surface every 3 seconds.

Researchers at Akishima Laboratories have developed similar devices in the past that used waves to draw pictures on the surface of water, but those devices had trouble producing letters with straight lines (such as the letter K). Additionally, it took the previous devices up to 15 minutes of data input time to produce each letter.

The newly developed technology uses improved calculation methods for controlling the wave generators, relying on formulas known as Bessel functions. In addition to being able to draw letters consisting of straight lines, the input time has been drastically reduced to between 15 and 30 seconds for each letter.

Akishima Laboratories expects the technology to be incorporated into amusement devices that combine acoustics, lighting and fountain technology, which they hope to see installed at theme parks and hotels.

再别康桥

轻轻的我走了 正如我轻轻的来
我轻轻的招手 作别西天的云彩

那河畔的金柳 是夕阳中的新娘

波光里的艳影 在我的心头荡漾

软泥上的青荇 油油的在水底招摇

在康河的柔波里 我甘心做一条水草

那树荫下的一潭 不是清泉 是天上虹

揉碎在浮藻间 沉淀着彩虹似的梦

寻梦 撑一支长篙 向青草更青处漫溯

满载一船星辉 在星辉斑斓里放歌

但我不能放歌 悄悄是别离的笙箫

夏虫也为我沉默 沉默是今晚的康桥

悄悄的我走了 正如我悄悄的来

我挥一挥衣袖 不带走一片云彩

重载、覆盖、多态与函数隐藏

zz from http://otherlanguage.chinadir.net/16889.htm
感觉不错，遂转之。
//************************************************
//************************************************

重载、覆盖、多态与函数隐藏

经常看到C++的一些初学者对于重载、覆盖、多态与函数隐藏的模糊理解。在这里写一点自己的见解，希望能够C++初学者解惑。

要弄清楚重载、覆盖、多态与函数隐藏之间的复杂且微妙关系之前，我们首先要来回顾一下重载覆盖等基本概念。

首先，我们来看一个非常简单的例子，理解一下什么叫函数隐藏hide。

#include

using namespace std;

class Base{

public:

void fun() { cout << "Base::fun()" <<>

};

class Derive : public Base{

public:

void fun(int i) { cout << "Derive::fun()" <<>

};

int main()

{

Derive d;

//下面一句错误，故屏蔽掉

//d.fun();error C2660: 'fun' : function does not take 0 parameters

d.fun(1);

Derive *pd =new Derive();

//下面一句错误，故屏蔽掉

//pd->fun();error C2660: 'fun' : function does not take 0 parameters

pd->fun(1);

delete pd;

return 0;

}

/*在不同的非命名空间作用域里的函数不构成重载,子类和父类是不同的两个作用域。

在本例中,两个函数在不同作用域中,故不够成重载,除非这个作用域是命名空间作用域。*/

在这个例子中，函数不是重载overload，也不是覆盖override，而是隐藏hide。

接下来的5个例子具体说明一下什么叫隐藏

例1

#include

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" <<>

void fun(int i){cout << "Base::fun(int i)" <<>

};

class Derive :public Basic{

public:

void fun2(){cout << "Derive::fun2()" <<>

};

int main()

{

Derive d;

d.fun();//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。

d.fun(1);//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。

return 0;

}

例2

#include

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" <<>

void fun(int i){cout << "Base::fun(int i)" <<>

};

class Derive :public Basic{

public:

//新的函数版本,基类所有的重载版本都被屏蔽,在这里,我们称之为函数隐藏hide

//派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。

void fun(int i,int j){cout << "Derive::fun(int i,int j)" <<>

void fun2(){cout << "Derive::fun2()" <<>

};

int main()

{

Derive d;

d.fun(1,2);

//下面一句错误，故屏蔽掉

//d.fun();error C2660: 'fun' : function does not take 0 parameters

return 0;

}

例3

#include

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" <<>

void fun(int i){cout << "Base::fun(int i)" <<>

};

class Derive :public Basic{

public:

//覆盖override基类的其中一个函数版本,同样基类所有的重载版本都被隐藏hide

//派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。

void fun(){cout << "Derive::fun()" <<>

void fun2(){cout << "Derive::fun2()" <<>

};

int main()

{

Derive d;

d.fun();

//下面一句错误，故屏蔽掉

//d.fun(1);error C2660: 'fun' : function does not take 1 parameters

return 0;

}

例4

#include

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" <<>

void fun(int i){cout << "Base::fun(int i)" <<>

};

class Derive :public Basic{

public:

using Basic::fun;

void fun(){cout << "Derive::fun()" <<>

void fun2(){cout << "Derive::fun2()" <<>

};

int main()

{

Derive d;

d.fun();//正确

d.fun(1);//正确

return 0;

}

/*

输出结果

Derive::fun()

Base::fun(int i)

Press any key to continue

*/

例5

#include

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" <<>

void fun(int i){cout << "Base::fun(int i)" <<>

};

class Derive :public Basic{

public:

using Basic::fun;

void fun(int i,int j){cout << "Derive::fun(int i,int j)" <<>

void fun2(){cout << "Derive::fun2()" <<>

};

int main()

{

Derive d;

d.fun();//正确

d.fun(1);//正确

d.fun(1,2);//正确

return 0;

}

/*

输出结果

Base::fun()

Base::fun(int i)

Derive::fun(int i,int j)

Press any key to continue

*/

[C++基础]重载、覆盖、多态与函数隐藏

好了，我们先来一个小小的总结重载与覆盖两者之间的特征

重载overload的特征：

n 相同的范围(在同一个类中)；

n 函数名相同参数不同；

n virtual 关键字可有可无。

覆盖override是指派生类函数覆盖基类函数，覆盖的特征是：

n 不同的范围(分别位于派生类与基类)；

n 函数名和参数都相同；

n 基类函数必须有virtual 关键字。(若没有virtual 关键字则称之为隐藏hide)

如果基类有某个函数的多个重载(overload)版本，而你在派生类中重写(override)了基类中的一个或多个函数版本，或是在派生类中重新添加了新的函数版本(函数名相同，参数不同)，则所有基类的重载版本都被屏蔽，在这里我们称之为隐藏hide。所以，在一般情况下，你想在派生类中使用新的函数版本又想使用基类的函数版本时，你应该在派生类中重写基类中的所有重载版本。你若是不想重写基类的重载的函数版本，则你应该使用例4或例5方式，显式声明基类名字空间作用域。

事实上，C++编译器认为，相同函数名不同参数的函数之间根本没有什么关系，它们根本就是两个毫不相关的函数。只是C++语 言为了模拟现实世界，为了让程序员更直观的思维处理现实世界中的问题，才引入了重载和覆盖的概念。重载是在相同名字空间作用域下，而覆盖则是在不同的名字 空间作用域下，比如基类和派生类即为两个不同的名字空间作用域。在继承过程中，若发生派生类与基类函数同名问题时，便会发生基类函数的隐藏。当然，这里讨 论的情况是基类函数前面没有virtual 关键字。在有virtual 关键字关键字时的情形我们另做讨论。

继承类重写了基类的某一函数版本，以产生自己功能的接口。此时C++编绎器认为，你现在既然要使用派生类的自己重新改写的接口，那我基类的接口就不提供给你了(当然你可以用显式声明名字空间作用域的方法，见[C++基础]重载、覆盖、多态与函数隐藏(1))。而不会理会你基类的接口是有重载特性的。若是你要在派生类里继续保持重载的特性，那你就自己再给出接口重载的特性吧。所以在派生类里，只要函数名一样，基类的函数版本就会被无情地屏蔽。在编绎器中，屏蔽是通过名字空间作用域实现的。

所以，在派生类中要保持基类的函数重载版本，就应该重写所有基类的重载版本。重载只在当前类中有效，继承会失去函数重载的特性。也就是说，要把基类的重载函数放在继承的派生类里，就必须重写。

这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，具体规则我们也来做一小结：

n 如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类无virtual关键字，基类的函数将被隐藏。(注意别与重载混淆，虽然函数名相同参数不同应称之为重载，但这里不能理解为重载，因为派生类和基类不在同一名字空间作用域内。这里理解为隐藏)

n 如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类有virtual关键字，基类的函数将被隐式继承到派生类的vtable中。此时派生类vtable中的函数指向基类版本的函数地址。同时这个新的函数版本添加到派生类中，作为派生类的重载版本。但在基类指针实现多态调用函数方法时，这个新的派生类函数版本将会被隐藏。

n 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏。(注意别与覆盖混淆，这里理解为隐藏)。

n 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数有virtual关键字。此时，基类的函数不会被“隐藏”。(在这里，你要理解为覆盖哦^_^)。

插曲：基类函数前没有virtual关键字时，我们要重写更为顺口些，在有virtual关键字时，我们叫覆盖更为合理些，戒此，我也希望大家能够更好的理解C++中一些微妙的东西。费话少说，我们举例说明吧。

例6

#include

using namespace std;

class Base{

public:

virtual void fun() { cout << "Base::fun()" <<>overload

virtual void fun(int i) { cout << "Base::fun(int i)" <<>overload

};

class Derive : public Base{

public:

void fun() { cout << "Derive::fun()" << style="">//override

void fun(int i) { cout << "Derive::fun(int i)" << style="">//override

void fun(int i,int j){ cout<< "Derive::fun(int i,int j)" <

};

int main()

{

Base *pb = new Derive();

pb->fun();

pb->fun(1);

//下面一句错误，故屏蔽掉

//pb->fun(1,2);virtual函数不能进行overload,error C2661: 'fun' : no overloaded function takes 2 parameters

cout <<>

Derive *pd = new Derive();

pd->fun();

pd->fun(1);

pd->fun(1,2);//overload

delete pb;

delete pd;

return 0;

}

/*

输出结果

Derive::fun()

Derive::fun(int i)

Derive::fun()

Derive::fun(int i)

Derive::fun(int i,int j)

Press any key to continue

*/

例7-1

#include

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<>

};

class Derive : public Base{};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Base::fun(int i)

delete pb;

return 0;

}

例7-2

#include

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<>

};

class Derive : public Base{

public:

void fun(double d){ cout <<"Derive::fun(double d)"<< style="">

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Base::fun(int i)

pb->fun((double)0.01);//Base::fun(int i)

delete pb;

return 0;

}

例8-1

#include

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<>

};

class Derive : public Base{

public:

void fun(int i){ cout <<"Derive::fun(int i)"<<>

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

delete pb;

return 0;

}

例8-2

#include

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<>

};

class Derive : public Base{

public:

void fun(int i){ cout <<"Derive::fun(int i)"<<>

void fun(double d){ cout <<"Derive::fun(double d)"<< style="">

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

pb->fun((double)0.01);//Derive::fun(int i)

delete pb;

return 0;

}

例9

#include

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<>

};

class Derive : public Base{

public:

void fun(int i){ cout <<"Derive::fun(int i)"<<>

void fun(char c){ cout <<"Derive::fun(char c)"<< style="">

void fun(double d){ cout <<"Derive::fun(double d)"<< style="">

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

pb->fun('a');//Derive::fun(int i)

pb->fun((double)0.01);//Derive::fun(int i)

Derive *pd =new Derive();

pd->fun(1);//Derive::fun(int i)

//overload

pd->fun('a');//Derive::fun(char c)

//overload

pd->fun(0.01);//Derive::fun(double d)

delete pb;

delete pd;

return 0;

}

例7-1和例8-1很好理解，我把这两个例子放在这里，是让大家作一个比较摆了，也是为了帮助大家更好的理解：

n 例7-1中，派生类没有覆盖基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是基类的虚函数地址。

n 例8-1中，派生类覆盖了基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是派生类自己的重写的虚函数地址。

在例7-2和8-2看起来有点怪怪，其实，你按照上面的原则对比一下，答案也是明朗的：

n 例7-2中，我们为派生类重载了一个函数版本：void fun(double d) 其实，这只是一个障眼法。我们具体来分析一下，基类共有几个函数，派生类共有几个函数：

类型	基类	派生类
Vtable部分	void fun(int i)	指向基类版的虚函数void fun(int i)
静态部分		void fun(double d)

我们再来分析一下以下三句代码

Base *pb = new Derive();

pb->fun(1);//Base::fun(int i)

pb->fun((double)0.01);//Base::fun(int i)

这第一句是关键，基类指针指向派生类的对象，我们知道这是多态调用；接下来第二句，运行时基类指针根据运行时对象的类型，发现是派生类对象，所以首先到派生类的vtable中去查找派生类的虚函数版本，发现派生类没有覆盖基类的虚函数，派生类的vtable只是作了一个指向基类虚函数地址的一个指向，所以理所当然地去调用基类版本的虚函数。最后一句，程序运行仍然埋头去找派生类的vtable，发现根本没有这个版本的虚函数，只好回头调用自己的仅有一个虚函数。

这里还值得一提的是：如果此时基类有多个虚函数，此时程序编绎时会提示”调用不明确”。示例如下

#include

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<>

virtual void fun(char c){ cout <<"Base::fun(char c)"<<>

};

class Derive : public Base{

public:

void fun(double d){ cout <<"Derive::fun(double d)"<< style="">

};

int main()

{

Base *pb = new Derive();

pb->fun(0.01);//error C2668: 'fun' : ambiguous call to overloaded function

delete pb;

return 0;

}

好了，我们再来分析一下例8-2。

n 例8-2中，我们也为派生类重载了一个函数版本：void fun(double d) ，同时覆盖了基类的虚函数，我们再来具体来分析一下，基类共有几个函数，派生类共有几个函数：

类型	基类	派生类
Vtable部分	void fun(int i)	void fun(int i)
静态部分		void fun(double d)

从表中我们可以看到，派生类的vtable中函数指针指向的是自己的重写的虚函数地址。

我们再来分析一下以下三句代码

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

pb->fun((double)0.01);//Derive::fun(int i)

第一句不必多说了，第二句，理所当然调用派生类的虚函数版本，第三句，嘿，感觉又怪怪的，其实呀，C++程序很笨的了，在运行时，埋头闯进派生类的vtable表中，只眼一看，靠，竞然没有想要的版本，真是想不通，基类指针为什么不四处转转再找找呢?呵呵，原来是眼力有限，基类年纪这么老了，想必肯定是老花了，它那双眼睛看得到的仅是自己的非Vtable部分(即静态部分)和自己要管理的Vtable部分，派生类的void fun(double d)那么远，看不到呀!再说了，派生类什么都要管，难道派生类没有自己的一点权力吗?哎，不吵了，各自管自己的吧^_^

唉!你是不是要叹气了，基类指针能进行多态调用，但是始终不能进行派生类的重载调用啊(参考例6)~~~

再来看看例9，

本例的效果同例6，异曲同工。想必你理解了上面的这些例子后，这个也是小Kiss了。

小结：

重载overload是根据函数的参数列表来选择要调用的函数版本，而多态是根据运行时对象的实际类型来选择要调用的虚virtual函数版本，多态的实现是通过派生类对基类的虚virtual函数进行覆盖override来实现的，若派生类没有对基类的虚virtual函数进行覆盖override的话，则派生类会自动继承基类的虚virtual函数版本，此时无论基类指针指向的对象是基类型还是派生类型，都会调用基类版本的虚virtual函数；如果派生类对基类的虚virtual函数进行覆盖override的话，则会在运行时根据对象的实际类型来选择要调用的虚virtual函数版本，例如基类指针指向的对象类型为派生类型，则会调用派生类的虚virtual函数版本，从而实现多态。

使用多态的本意是要我们在基类中声明函数为virtual，并且是要在派生类中覆盖override基类的虚virtual函 数版本，注意，此时的函数原型与基类保持一致，即同名同参数类型；如果你在派生类中新添加函数版本，你不能通过基类指针动态调用派生类的新的函数版本，这 个新的函数版本只作为派生类的一个重载版本。还是同一句话，重载只有在当前类中有效，不管你是在基类重载的，还是在派生类中重载的，两者互不牵连。如果明 白这一点的话，在例6、例9中，我们也会对其的输出结果顺利地理解。

重载是静态联编的，多态是动态联编的。进一步解释，重载与指针实际指向的对象类型无关，多态与指针实际指向的对象类型相关。若基类的指针调用派生类的重载版本，C++编绎认为是非法的，C++编绎器只认为基类指针只能调用基类的重载版本，重载只在当前类的名字空间作用域内有效，继承会失去重载的特性，当然，若此时的基类指针调用的是一个虚virtual函数，那么它还会进行动态选择基类的虚virtual函数版本还是派生类的虚virtual函数版本来进行具体的操作，这是通过基类指针实际指向的对象类型来做决定的，所以说重载与指针实际指向的对象类型无关，多态与指针实际指向的对象类型相关。

最后阐明一点，虚virtual函数同样可以进行重载，但是重载只能是在当前自己名字空间作用域内有效(请再次参考例6)。