对C++虚函数使用的深刻体会,以及覆写,重载的区别?

虚函数就是实现函数的覆写,

它们以下特点:

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual关键字

还有,要注意一点,函数的返回值是影响不了覆写和重载函数的.

我的以下程序,思路 不对的地方就是没能完全理解多态的应用,

#include <iostream>

#include <vector>

#include <string>

using namespace std;

class A

{

};

class BA: public A

{

public:

int m_i;

int getValue()

{

return m_i;

}

};

class CA: public A

{

public:

string m_str;

string getValue()

{

return m_str;

}

};

class DA : public A

{

public:

vector <A *> m_vec;

};

int main()

{

BA *pBa = new BA;

pBa->m_i = 100;

CA *pCa = new CA;

pCa->m_str = "myprogram";

DA da;

da.m_vec.push_back(pBa);

da.m_vec.push_back(pCa);

//请问一下，我要在这里输出da.m_vec的所有内容，应该如何实现呢？

vector<A *> :: iterator it;

for (it = da.m_vec.begin(); it != da.m_vec.end(); it++)

{

(*it)->getValue(); // error,其类A没有该虚函数实现.

}

return 0;

}

在以上程序中, CA的string getValue()函数和BA的int getValue()函数即使加了virtual ,也不能成为多态,一是基类A没有相应的虚函数,二是int 和string的返回类型不一致.因此,在实现输出的话,需要在A类中写一个纯虚函数,然后在各自的子类上覆写该虚函数,写上分别的实现即可.

因此,可以写成下面的样子:

#include <iostream> #include <vector>

#include <string>

using namespace std;

class A

{

public:

void pout() { doout(); }

virtual void doout()=0;

};

class BA: public A

{

public:

void doout() { cout<<m_i<<" ";
}

int m_i;

};

class CA: public A

{

public:

void doout() { cout<<m_str<<" ";
}

string m_str;

};

class DA : public A

{

public:

void doout() {

for (vector<A *>::iterator
it=m_vec.begin();it!=m_vec.end();++it)

(*it)->doout();

}

vector <A *> m_vec;

};

int main()

{

BA *pBa = new BA;

pBa->m_i = 100;

CA *pCa = new CA;

pCa->m_str = "myprogram";

DA da;

da.m_vec.push_back(pBa);

da.m_vec.push_back(pCa);

da.doout();

return 0;

}

下面的网友邦的建议:

不要用这样的语句

cout < < ((A *)(it))->getValue() < < endl;

由于返回类型不一致，很难在基类里声明。把输出功能，放到派生类里去，用一个基类虚函数调用。这样就可以*it.foo()来实现输出了。

是把输出放到派生类的虚函数定义中，在基类用一个非虚函数调用虚函数来实现输出。

=============================================================================================================

以下是重载和覆写的区别?(网上搜到的,转)

重载和覆写有什么区别?

重载有对于已有的方法或操作符进行重构,方法被重载后可以通过其重载的形式或方法原形来调用,有几个重载就有几个调用的形式;操作符重载后会变成你重构的定义.

而覆写则是将之前的方法进行隐藏

重载提供了对一个方法签名的不同参数调用的实现。

覆写提供了子类中改变父类方法行为的实现。

其实很本质的区别就是看函数特征：覆写（Override）的两个函数的函数特征相同，重载（Overload）的两个函数的函数名虽然相同，但函数特征不同。

函数特征包括函数名，参数的类型和个数。

Override 是在继承的时候，如果你写的函数与要继承的函数函数特征相同，那么，加上这个关键字，在使用这个子类的这个函数的时候就看不见父类（或超类）的函数了，它被覆盖掉了。

比如：Derived继承了Base，Base里面有void A(int a)

那么如果你Derived里面觉得A写得不好或不适合这个类，你想重新再写一遍A里的代码，那么就写override void A(int a)这样，原来的那个函数就被你新写的这个覆盖掉了。

Overload 是重载，就是说函数名相同，函数特征不同，系统会根据你提供的参数来调相应的函数。

比如：void A(int a)和void A(int a,int b)

如果你用的是A(1)那么调的是第一个，如果是A(1,1)那么调的是第二个。

都说的好，重载和覆盖还有个关键区别就是：

重载的既可以是父类的方法也可以是子类的方法（虽然名字相同但是参数不同）

而覆盖就是在子类中定义一个和父类一样的方法(关键是名字和参数都是一样的），用中文覆盖来说明这种现象是在好不过了。。。。。。。

重载与覆盖

成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual关键字可有可无。

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

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual关键字

举例说明:

覆写(overriding):

class A {

System.out.println("This is class A");

}

class B extends A {

System.out.println("This is class B");

}

重载(overloading):

class C {

void print(int i) {

System.out.println(i);

}

void print(float f) {

System.out.println(f);

}

}