c++ 重载，覆盖，重定义 2

前一篇 http://www.cnblogs.com/iois/p/4085173.html
写有些地方不够准确，重新整理了一遍

函数重载（Function Overloading）

C++允许同一范围（scope）（ 在同一个类中 ）内具有多个名称相同的函数。这些函数成为重载函数（overloaded function）。

C++ 使用函数声明的参数数量，参数类型，省略号存在或缺失 （ Presence or absence of ellipsis ）， const 或 volatile来区分同一范围内具有相同名称的函数组。
http://msdn.microsoft.com/zh-cn/library/5dhe1hce.aspx

重定义（redefining，也叫隐藏）：

派生类的函数屏蔽了与其同名的基类函数；

1. 若派生类的函数与基类的函数名称相同，但参数类表不同，则基类函数被隐藏（不管基类函数有无virtual修饰）；
2. 若派生类的函数与基类的函数名称相同，参数列表相同，但基类函数无virtual修饰，则基类函数被隐藏。

重定义：一个继承了的成员函数的定义可以在派生类中进行修改，使其在派生类中的含义有别于基类中的含义。
我想使用基类给出的函数的定义，虽然我是一个派生类：son_obj.father::f();

---

自己的理解 ：重载、重定义 <-->覆盖

重定义是发生在基类 派生类 这样的范围内的 重载
重载 和 重定义 其实是一类 东西，本质有别于 覆盖

---

覆盖（override，重写）（用于实现多态，动态绑定）：

子类重写定义基类中有相同名字相同参数的虚函数。

• 不同范围内（基类 派生类）
• 函数名相同
• 参数相同
• 基类函数有virtual关键字修饰

virtual函数是private的，派生类中可重写为public 或者protected。

自己的理解 ：动态绑定 <-->覆盖/重写

override:
凌驾；不理会；比…更重要；超驰控制
[网络] 覆盖；重写；覆写

http://www.cnblogs.com/kevinGaoblog/archive/2012/08/25/2656989.html

http://blog.163.com/clevertanglei900@126/blog/static/111352259201102441934870/

---

[c++面向对象程序设计 第6版]:

---

多态：用一些特定的方式为一个函数名称关联多种含义的能力。
动态绑定：不知道这个函数如何实现，在运行时再确定一个函数的具体实现。

#include <iostream>
using namespace std;


class figure
{
public:
virtual void draw(){cout<<"draw fig "<<endl;}
void center(){cout<<"move to center-";this->draw();}
//派生类要调用统一的center()函数，
//但center()的draw()是根据派生类的类型决定的；
//写到这里的时候我们还不知道draw()的具体实现是什么
//这里就需要draw()函数有不同的含义，对应不同的实现（多态）
};


class rectangle:public figure
{
public:
void draw(){cout<<"draw rectangle "<<endl;}
};


int main()
{
figure *f=new rectangle();
f->center();
return 0;
}

---

class father{

public:
father(){};
virtual ~father(){};
// virtual修饰 子类成员函数覆盖override基类成员函数
virtual void output(){cout<<"father"<<endl;}
};
class son: public father{
public:
son(){};
virtual ~son(){};
void output(){cout<<"son"<<endl;}
};


void showname(father* x){
x->output();
}


int main(){
father *f=new father();
son *s=new son();
showname(f);
showname(s);
return 1;
}

输出：

father
son

若无virtual，则：

#include <iostream>
using namespace std;


class father{
public:
father(){};
virtual ~father(){};
void output(){cout<<"father"<<endl;}
};
class son: public father{
public:
son(){};
virtual ~son(){};
void output(){cout<<"son"<<endl;}
};


void showname(father* x){
x->output();
}


int main(){
father *f=new father();
son *s=new son();
showname(f);
showname(s);
return 1;
}

输出

father
father