威尼斯www.9778.com-威尼斯正版官方网站

威尼斯正版官方网站C++中的基类与派生类

日期:2020-01-15编辑作者:编程人生

一、 C++成员函数的重载

C++中的成员函数有四种,分别是普通成员函数,virtual虚函数,const成员函数。

  • (1) void func(int a);
  • (2) virtual void func(int a);
  • (3) void func(int a) const;

如果在一个类中,声明这四种函数,哪是重复定义?哪些是重载?

其中(1)(2)是重复定义,故编译不能通过,而(3)与(1)(2)是不同类型的函数,是重载。

成员函数被重载的特征是:

  • (1)具有相同的作用域(即同一个类定义中);
  • (2)函数名字相同
  • (3)参数类型,顺序 或 数目不同(包括const参数和非const函数)
  • (4)virtual关键字可有可无。

从成员函数的重载特征中,可以知道(1)(2)是重复定义。那么(3)为什么和(1)(2)不同呢?

因为类中的函数,都会自动添加一个自身类指针this,所以

void func(int a) ==== void func(Base * this, int a)

virtual func(int a) ==== virtual func(Base *this, int a)

void func(int a)const === void func(const Base *this, int a) const

所以(3)可以与(1)(2)发生重载,因为参数有一个const。

派生类的继承方式总结:

【转载】C++中的基类与派生类,

转自:http://www.cnblogs.com/sujz/articles/2044365.html

二 、C++成员函数的继承

#include <iostream> 
using namespace std; 

class Base { 
public: 
    void f(int a){ 
        cout << "Base::f(int a)" << endl; 
    } 
    virtual void g(int a) { 
        cout << "virtual Base::g(int a)" << endl; 
    } 
}; 

class Derived : public Base 
{ 
public: 
    void h(int a) { 
        cout << "Derivd::h(int a)" << endl; 
    } 
}; 

int main() 
{ 
    Base b; 
    b.f(3); 
    b.g(4); 

    Derived d; 
    d.f(3); 
    d.g(4); 
    d.h(3); 
} 

#include <iostream>
using namespace std;

class Base {
public:
 void f(int a){
  cout << "Base::f(int a)" << endl;
 }
 virtual void g(int a) {
  cout << "virtual Base::g(int a)" << endl;
 }
};

class Derived : public Base
{
public:
 void h(int a) {
  cout << "Derivd::h(int a)" << endl;
 }
};

int main()
{
 Base b;
 b.f(3);
 b.g(4);

 Derived d;
 d.f(3);
 d.g(4);
 d.h(3);
}

Base b的对象模型:

威尼斯正版官方网站 1

Derived d的对象模型:

威尼斯正版官方网站 2

则在子类Derived d中继承了父类中的virtual void g(int a) ; void f(int a);

运行结果为:

威尼斯正版官方网站 3

 

 

三、C++成员函数的覆盖

覆盖是指派生类重新实现(或者改写)了基类的成员函数,其特征是:

  • (1)不同的作用域(非别位于派生类和基类中);
  • (2)函数名称相同
  • (3)参数列表完全相同;
  • (4)基类函数必须是虚函数。

从(4)中我们得知覆盖只是针对虚函数的。

#include <iostream> 
using namespace std; 

class Base { 
public: 
    void f(int a){ 
        cout << "Base::f(int a)" << endl; 
    } 
    virtual void g(int a) { 
        cout << "virtual Base::g(int a)" << endl; 
    } 
}; 

class Derived : public Base 
{ 
public: 
    void h(int a) { 
        cout << "Derivd::h(int a)" << endl; 
    } 
    virtual void g(int a) { 
        cout << "virtual Derived::g(int a)" << endl; 
    } 
}; 

int main() 
{ 
    Base b; 
    b.f(3); 
    b.g(4); 

    Derived d; 
    d.f(3); 
    d.g(4); 
    d.h(3); 
} 

#include <iostream>
using namespace std;

class Base {
public:
 void f(int a){
  cout << "Base::f(int a)" << endl;
 }
 virtual void g(int a) {
  cout << "virtual Base::g(int a)" << endl;
 }
};

class Derived : public Base
{
public:
 void h(int a) {
  cout << "Derivd::h(int a)" << endl;
 }
 virtual void g(int a) {
  cout << "virtual Derived::g(int a)" << endl;
 }
};

int main()
{
 Base b;
 b.f(3);
 b.g(4);

 Derived d;
 d.f(3);
 d.g(4);
 d.h(3);
}

Derived d对象模型如下:

威尼斯正版官方网站 4

其中Derived中重新定义了基类的虚成员函数virtual void g(int a);

威尼斯正版官方网站 5

继承方式 说明

派生类的继承方式总结:

继承方式 说明
public 基类的public和protected的成员被派生类继承后,保持原来的状态
private 基类的public和protected的成员被派生类继承后,变成派生类的private成员
protected

基类的public和protected的成员被派生类继承后,变成派生类的protected成员

 

注:无论何种继承方式,基类的private成员都不能被派生类访问。从上面的表中可以看出,声明为public的方法和属性可以被随意访问;声明为protected的方法和属性只能被类本身和其子类访问;而声明为private的方法和属性只能被当前类的对象访问。  

1. 友元函数必须在类中进行声明而在类外定义,声明时须在函数返回类型前面加上关键字friend。友元函数虽不是类的成员函数,但它可以访问类中的私有和保护类型数据成员。  

2. 虚函数在重新定义时参数的个数和类型必须和基类中的虚函数完全匹配,这一点和函数重载完全不同。  

  1. #include <文件名>和#include "文件名"  
  • 文件包含的两种格式中,第一种格式用来包含那些由系统提供的并放在指定子目录中的头文件;而第二种格式用来包含那些由用户自己定义的放在当前目录或其他目录下的头文件或其它源文件。  

4. 数组也可以作为函数的实参和形参,若数组元素作为函数的实参,则其用法与变量相同。当数组名作为函数的实参和形参时,传递的是数组的地址。当进行按值传递的时候,所进行的值传送是单向的,即只能从实参传向形参,而不能从形参传回实参。形参的初值和实参相同,而形参的值发生改变后,实参并不变化,两者的终值是不同的。而当用数组名作为函数参数进行传递时,由于实际上实参和形参为同一数组,因此当形参数组发生变化时,实参数组也随之发生变化。  

注:实参数组与形参数组类型应一致,如不一致,结果将出错;形参数组也可以不指定大小,在定义数组时数组名后面跟一个空的方括号,为了在被调用函数中处理数组元素的需要,可以另设一个参数,传递数组元素的个数。如:int sum(int array[],int n);  

  1. 重载、覆盖和隐藏的区别?  

函数的重载是指C++允许多个同名的函数存在,但同名的各个函数的形参必须有区别:形参的个数不同,或者形参的个数相同,但参数类型有所不同。 

覆盖(Override)是指派生类中存在重新定义的函数,其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致,覆盖函数和被覆盖函数只有函数体 (花括号中的部分)不同,当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本,而不是父类中的被覆盖函数版本,这种机制就叫做覆盖。

下面我们从成员函数的角度来讲述重载和覆盖的区别。

成员函数被重载的特征有: 1) 相同的范围(在同一个类中);2) 函数名字相同;3) 参数不同;4) virtual关键字可有可无。

覆盖的特征有: 1) 不同的范围(分别位于派生类与基类);2) 函数名字相同;3) 参数相同;4) 基类函数必须有virtual关键字。

比如,在下面的程序中:

威尼斯正版官方网站 6 #include <iostream.h>
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};

class Derived : public Base
{
public:
virtual void g(void){ cout << "Derived::g(void)" << endl;}
};

void main(void)
{
Derived d;
Base *pb = &d;
pb->f(42); // 运行结果: Base::f(int) 42
pb->f(3.14f); // 运行结果: Base::f(float) 3.14
pb->g(); // 运行结果: Derived::g(void)
} 威尼斯正版官方网站 7

 

函数Base::f(int)与Base::f(float)相互重载,而Base::g(void)被Derived::g(void)覆盖。

隐藏是指派生类的函数屏蔽了与其同名的基类函数,规则如下: 1) 如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。2) 如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。

比如,在下面的程序中:

 

威尼斯正版官方网站 8 #include <iostream.h>

class Base
{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
void g(float x){ cout << "Base::g(float) " << x << endl; }
void h(float x){ cout << "Base::h(float) " << x << endl; }
};

class Derived : public Base
{
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }//被继承之后,virtual 可有可无,但最好有。继承后,还是虚函数。
void g(int x){ cout << "Derived::g(int) " << x << endl; }
void h(float x){ cout << "Derived::h(float) " << x << endl; }
using Base::g;//这句话是用来引用父类中被隐藏的部分的。
}; 威尼斯正版官方网站 9

 

通过分析可得:

1) 函数Derived::f(float)覆盖了Base::f(float)。

2) 函数Derived::g(int)隐藏了Base::g(float),注意,不是重载。

3) 函数Derived::h(float)隐藏了Base::h(float),而不是覆盖。

看完前面的示例,可能大家还没明白隐藏与覆盖到底有什么区别,因为我们前面都是讲的表面现象,怎样的实现方式,属于什么情况。下面我们就要分析覆盖与隐藏在应用中到底有什么不同之处。在下面的程序中bp和dp指向同一地址,按理说运行结果应该是相同的,可事实并非如此。

 

威尼斯正版官方网站 10 void main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good: behavior depends solely on type of the object
pb->f(3.14f); //运行结果: Derived::f(float) 3.14
pd->f(3.14f); //运行结果: Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer
pb->g(3.14f); //运行结果: Base::g(float) 3.14
pd->g(3.14f); //运行结果: Derived::g(int) 3
// Bad : behavior depends on type of the pointer
pb->h(3.14f); //运行结果: Base::h(float) 3.14
pd->h(3.14f); //运行结果: Derived::h(float) 3.14
} 威尼斯正版官方网站 11

 

请大家注意,f()函数属于覆盖,而g()与h()属于隐藏。从上面的运行结果,我们可以注意到在覆盖中,用基类指针和派生类指针调用函数f() 时,系统都是执行的派生类函数f(),而非基类的f(),这样实际上就是完成的“接口”功能。而在隐藏方式中,用基类指针和派生类指针调用函数f()时,系统会进行区分,基类指针调用时,系统执行基类的f(),而派生类指针调用时,系统“隐藏”了基类的f(),执行派生类的f(),这也就是“隐藏”的由来。

重载(overload):这个好理解,在同个space域同名的。参数必须不同,有关virtual无关.

覆盖(override):同名字,同参数,有virtual,覆盖好理解比如show()函数,A派生了B,如果B中的show()覆盖了A中的show(),但B中仍然有两个show(),而不管是A类指针也好,B类对象调用也好,都只能调用B类自己的那个show();而从A类继承过来的show()函数真的就被覆盖了,没有了吗? 答案是不对的.这时可以在B类对象显示的调用A类继承过来的show();

程序代码:

 

威尼斯正版官方网站 12 #include <iostream> 
using namespace std; 

class A 

public: 
virtual void show() 

cout << a << endl; 

int a; 
}; 

class B:public A 

public: 
void show() 

A::show(); 
//显式地调用自己类中的 "由A类继承过来的show()函数" ,像这种直接显式指出某个类的某个函数时, 编译器处理方式是这样的: 首先在自己类中找有没有A::show(),如果找到,调用.不在继续在A类中找,如果找不到,则在显式指出的那个类中(即A类)调用那个函数. 这里当然是在B类中可以找到A::show() ,因为基类中指出了这个函数是virtual函数. 

int b; 
};

int main() 

A a; 
a.a = 3; 
a.show(); 

B b; 
b.b = 4; 
b.show(); 
b.A::show(); //显示的调用自己类中的 "由A类继承过来的show()函数"

return 0; 
} 威尼斯正版官方网站 13

 

总结:

通俗的讲B类还是有两个show(),只是调用由A继承过来的show()只能通过显式的调用方法 [类名::virtual函数名] 而不管是基类A的指针 (B b; A *p = &b; p->show())或者派生类的对象(B b; b.show()),都只能调用B类的自己本身存在的show()函数

隐藏hide:

1:同名同参无virtual

2:同名不同参不管有无virtual

程序代码:

 

威尼斯正版官方网站 14 class A 

public: 
void show() {}; //编号1 
void rose(int a) {}  //编号2 
}; 

class B:public A 

public: 
void show() {}; //编号3 
void rose(int a, int b) {}; //编号4 
}; 威尼斯正版官方网站 15

 

类B中的show()和rose()明显是隐藏了类A的show()和rose() 隐藏的理解: B类中其实有两个show(),两个rose(); 但为什么不叫重载呢?你会这样想,但我可以告诉你,因为类B中的两个show(),两个rose(),不是都可以被B类的对象调用的.

编号1和编号2,在类B中哪怕存在,但只能通过类A的指针调用,而不能通过B类对象调用,如:

程序代码:

 

A *p = new B; 
p->show(); 
p->rose(3); 
p->rose(3,5); //error

 

编号3和编程4,只能通过类B对象调用,而不能通过类A的指针调用,如:

程序代码:

 

B b; 
b.show(); 
b.rose(3,5); 
b.rose(4); //error

 

  1. 用参数列表可以区分重载函数,为什么返回值却不能区分重载函数?

比如说有两个函数:int fun(); double fun(); 如果写fun();那么编译器就不知道该调用谁了。函数调用结束后才能确定返回值,但程序在调用函数时就需要明确知道调用哪一个重载的函数,这前后矛盾。

  1. 派生类与基类之间的关系
  • 派生类对象可以使用基类的方法,条件是方法在基类中没有被声明为私有的。基类指针可以在不进行显式类型转换的情况下指向派生类对象,基类引用可以在不进行显式类型转换的情况下引用派生类对象。不过,基类指针或引用只能用于调用基类方法,不能调用派生类的方法。通常C++要求引用和指针类型与赋给的类型匹配,但这一规则对继承来说是个例外。不过这种例外只是单向的,不可以将基类对象和地址赋给派生类引用和指针。
  1. 静态联编和动态联编

程序调用函数时,将使用哪个可执行代码块呢?编译器负责回答这个问题。将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编。在C语言中,这非常简单,因为每个函数名都对应一个不同的函数。在C++中,由于函数重载的缘故,这项任务更复杂。编译器必须查看函数参数以及函数名才能确定使用哪个函数。然而,C/C++编译器可以在编译过程完成这种联编。在编译过程中进行联编被称为静态联编/绑定,又称为早期联编/绑定。不过,虚函数使这项工作变得更困难。因为使用哪个函数是不能在编译时确定的,因为编译器不知道用户将选择哪种类型的对象。所以,编译器必须生成能够在程序运行时选择正确的虚方法的代码,这被称为动态联编/绑定,又被称为晚期联编/绑定。

 

转自: 派生类的继承方式总结: 继承方式 说明 public 基类的public和...

四、C++成员函数的隐藏

隐藏是指派生类的成员函数遮蔽了与其同名的基类成员函数,具体规则如下:

(1) 派生类的函数与基类的函数同名,但是参数列表有所差异。此时,不论有无virtual关键字,基类的函数在派生类中将被隐藏。(注意别与重载混合)

(2)派生类的函数与基类的函数同名,参数列表也相同,但是基类函数没有virtual关键字。此时,基类的函数在派生类中将被吟唱。(注意别与覆盖混合)

判断下面哪些函数是覆盖,哪些函数是隐藏?

#include <iostream> 
using namespace std; 

class Base { 
public: 
    virtual void f(float x) { 
        cout << "virtual Base::f(float) " << x << endl; 
    } 
    void g(float x) { 
        cout << "Base::g(float) " << x << endl; 
    } 
    void h(float x) { 
        cout << "Base::h(float) " << x << endl; 
    } 
}; 

class Derived : public Base{ 
public: 
    virtual void f(float x) { 
        cout << "virtual Derived::f(float) " << x << endl; 
    } 
    void g(int x) { 
        cout << "Derived::g(int) " << x << endl; 
    } 
    void h(float x) { 
        cout << "Derived::h(float) " << x << endl; 
    } 
}; 

int main(void) 
{ 
    Derived d; 
    Base *pb = &d; 
    Derived *pd = &d; 

    pb->f(3.14f); 
    pd->f(3.14f); 

    pb->g(3.14f); 
    pd->g(3.14f); 

    pb->h(3.14f); 
    pd->h(3.14f); 
} 

#include <iostream>
using namespace std;

class Base {
public:
 virtual void f(float x) {
  cout << "virtual Base::f(float) " << x << endl;
 }
 void g(float x) {
  cout << "Base::g(float) " << x << endl;
 }
 void h(float x) {
  cout << "Base::h(float) " << x << endl;
 }
};

class Derived : public Base{
public:
 virtual void f(float x) {
  cout << "virtual Derived::f(float) " << x << endl;
 }
 void g(int x) {
  cout << "Derived::g(int) " << x << endl;
 }
 void h(float x) {
  cout << "Derived::h(float) " << x << endl;
 }
};

int main(void)
{
 Derived d;
 Base *pb = &d;
 Derived *pd = &d;

 pb->f(3.14f);
 pd->f(3.14f);

 pb->g(3.14f);
 pd->g(3.14f);

 pb->h(3.14f);
 pd->h(3.14f);
}

其中子类Derived中 vitual void f(float x)  是覆盖,而void g(int x) 和void h(float x)都是隐藏。

运行结果:

威尼斯正版官方网站 16

再看一个例子:

#include <iostream> 
using namespace std; 

class Base 
{ 
public: 
    virtual void f(int a) { 
        cout << "virtual Base::f(int a)" << endl; 
    } 

    void f(double d) { 
        cout << "Base::f(double d)" << endl;  
    } 
}; 

class Derived : public Base 
{ 
public: 

    void f(double d) { 
        cout << "Derivd::f(double d)" << endl; 
    } 
}; 

int main() 
{ 
    Derived d; 
    d.f(3); 
    d.f(2.5); 

    Derived *pd = new Derived(); 
    pd->f(3); 
    pd->f(2.5); 

    Base b; 
    b.f(5); 
    b.f(3.5); 

    Base *pBase = new Derived(); 
    pBase->f(5); 
    pBase->f(3.5); 
} 

#include <iostream>
using namespace std;

class Base
{
public:
 virtual void f(int a) {
  cout << "virtual Base::f(int a)" << endl;
 }

 void f(double d) {
  cout << "Base::f(double d)" << endl;
 }
};

class Derived : public Base
{
public:

 void f(double d) {
  cout << "Derivd::f(double d)" << endl;
 }
};

int main()
{
 Derived d;
 d.f(3);
 d.f(2.5);

 Derived *pd = new Derived();
 pd->f(3);
 pd->f(2.5);

 Base b;
 b.f(5);
 b.f(3.5);

 Base *pBase = new Derived();
 pBase->f(5);
 pBase->f(3.5);
}

其中父类中的void f(double d)隐藏了子类的virtual void f(int a),  void f(double d)函数。

所以在主函数中

Derived d; 
d.f(3); 
d.f(2.5); 

Derived *pd = new Derived(); 
pd->f(3); 
pd->f(2.5); 

Derived d;
d.f(3);
d.f(2.5);

Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);只要通过Derived对象或者Derived指针执行f()函数,都只执行void Derived::f(double d)该函数。

[html]
Base *pBase = new Derived(); 
pBase->f(5); 
pBase->f(3.5); 

Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);

在调用pBase->f(5)时,首先要去pBase类中找到对应需要执行的函数,因为Base类中有两个函数virtual void f(int a) 和 void f(double)重载,因为该实参是5,为int类型,所以要调用virtual void f(int a)函数,因为该f(int a)是一个虚函数,所以再去判断pBase所指向的具体对象,具体对象为Derived子类,再去Derived子类的虚函数表中找到void f(int a)函数。因为Derived子类继承了父类Base的虚函数vitural void f(int a),所以输出 virtual Base::f(int a);

在调用pBase->f(3.5)时,首先要去pBase类中找到对应需要执行的函数,因为因为Base类中有两个函数virtual void f(int a) 和 void f(double)重载,因为该实参是3.5,为double类,所以要调用void f(double d)函数,因为该函数是一个普通成员函数,故直接输出。 void Base::f(double d);

威尼斯正版官方网站 17

再举一个例子:

#include <iostream> 
using namespace std; 

class Base 
{ 
public: 
    virtual void f(int a) { 
        cout << "virtual Base::f(int a)" << endl; 
    } 

    void f(double d) { 
        cout << "Base::f(double d)" << endl;  
    } 
}; 

class Derived : public Base 
{ 
public: 

    void f(int a) { 
        cout << "virtual Derived::f(int a)" << endl; 
    } 
}; 

int main() 
{ 
    Derived d; 
    d.f(3); 
    d.f(2.5); 

    Derived *pd = new Derived(); 
    pd->f(3); 
    pd->f(2.5); 

    Base b; 
    b.f(5); 
    b.f(3.5); 

    Base *pBase = new Derived(); 
    pBase->f(5); 
    pBase->f(3.5); 
} 

#include <iostream>
using namespace std;

class Base
{
public:
 virtual void f(int a) {
  cout << "virtual Base::f(int a)" << endl;
 }

 void f(double d) {
  cout << "Base::f(double d)" << endl;
 }
};

class Derived : public Base
{
public:

 void f(int a) {
  cout << "virtual Derived::f(int a)" << endl;
 }
};

int main()
{
 Derived d;
 d.f(3);
 d.f(2.5);

 Derived *pd = new Derived();
 pd->f(3);
 pd->f(2.5);

 Base b;
 b.f(5);
 b.f(3.5);

 Base *pBase = new Derived();
 pBase->f(5);
 pBase->f(3.5);
}

子类Derived中的void f(int a)既覆盖了基类Base的虚函数virtual void f(int a),也隐藏了基类的virtual void f(int a),  void f(double d)函数。

Derived d; 
d.f(3); 
d.f(2.5); 

Derived *pd = new Derived(); 
pd->f(3); 
pd->f(2.5); 

Derived d;
d.f(3);
d.f(2.5);

Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);

同理所有用子类对象或者子类指针来调用f()函数时,都只执行virtual void f(int a),输出virtual Derived::f(int a)

view plaincopyprint?Base *pBase = new Derived(); 
pBase->f(5); 
pBase->f(3.5); 

Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);

pBase->f(5),首先去Base类中寻找相应的函数,同理Base类中的两个函数virtual void f(int a)和void f(double d)是重载函数,因为实参为5,为int类型,所以我们要调用virtual void f(int a)虚函数,因为该函数是虚函数,所以要去判断pBase指向的具体对象,因为pBase指向的是一个子类的对象,所以需要去子类的虚函数表中取找virtual void f(int a)函数,找到之后,执行该函数,故输出virtual Derived::f(int a)。

pBase->f(3.5),首先去Base类中寻找相应的函数,同理Base类中的两个函数virtual void f(int a)和void f(double d)是重载函数,因为实参为3.5,为double类型,所以我们要调用void f(double d),因为该函数为普通成员函数,故执行输出: void Base::f(double d);

威尼斯正版官方网站 18

public 基类的public和protected的成员被派生类继承后,保持原来的状态

private 基类的public和protected的成员被派生类继承后,变成派生类的private成员

protected  基类的public和protected的成员被派生类继承后,变成派生类的protected成员

 

注:无论何种继承方式,基类的private成员都不能被派生类访问。从上面的表中可以看出,声明为public的方法和属性可以被随意访问;声明为protected的方法和属性只能被类本身和其子类访问;而声明为private的方法和属性只能被当前类的对象访问。  

 

1. 友元函数必须在类中进行声明而在类外定义,声明时须在函数返回类型前面加上关键字friend。友元函数虽不是类的成员函数,但它可以访问类中的私有和保护类型数据成员。  

 

2. 虚函数在重新定义时参数的个数和类型必须和基类中的虚函数完全匹配,这一点和函数重载完全不同。  

 

3. #include <文件名>和#include "文件名"  

 

文件包含的两种格式中,第一种格式用来包含那些由系统提供的并放在指定子目录中的头文件;而第二种格式用来包含那些由用户自己定义的放在当前目录或其他目录下的头文件或其它源文件。  

 

4. 数组也可以作为函数的实参和形参,若数组元素作为函数的实参,则其用法与变量相同。当数组名作为函数的实参和形参时,传递的是数组的地址。当进行按值传递的时候,所进行的值传送是单向的,即只能从实参传向形参,而不能从形参传回实参。形参的初值和实参相同,而形参的值发生改变后,实参并不变化,两者的终值是不同的。而当用数组名作为函数参数进行传递时,由于实际上实参和形参为同一数组,因此当形参数组发生变化时,实参数组也随之发生变化。  

 

注:实参数组与形参数组类型应一致,如不一致,结果将出错;形参数组也可以不指定大小,在定义数组时数组名后面跟一个空的方括号,为了在被调用函数中处理数组元素的需要,可以另设一个参数,传递数组元素的个数。如:int sum(int array[],int n);  

 

5. 重载、覆盖和隐藏的区别?  

 

函数的重载是指C++允许多个同名的函数存在,但同名的各个函数的形参必须有区别:形参的个数不同,或者形参的个数相同,但参数类型有所不同。 

 

覆盖(Override)是指派生类中存在重新定义的函数,其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致,覆盖函数和被覆盖函数只有函数体 (花括号中的部分)不同,当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本,而不是父类中的被覆盖函数版本,这种机制就叫做覆盖。

 

下面我们从成员函数的角度来讲述重载和覆盖的区别。

 

成员函数被重载的特征有: 1) 相同的范围(在同一个类中);2) 函数名字相同;3) 参数不同;4) virtual关键字可有可无。

 

覆盖的特征有: 1) 不同的范围(分别位于派生类与基类);2) 函数名字相同;3) 参数相同;4) 基类函数必须有virtual关键字。

 

比如,在下面的程序中:

 

#include <iostream.h>

class Base

{

public:

void f(int x){ cout << "Base::f(int) " << x << endl; }

void f(float x){ cout << "Base::f(float) " << x << endl; }

virtual void g(void){ cout << "Base::g(void)" << endl;}

};

 

class Derived : public Base

{

public:

virtual void g(void){ cout << "Derived::g(void)" << endl;}

};

 

void main(void)

{

Derived d;

Base *pb = &d;

pb->f(42); // 运行结果: Base::f(int) 42

pb->f(3.14f); // 运行结果: Base::f(float) 3.14

pb->g(); // 运行结果: Derived::g(void)

}

 

函数Base::f(int)与Base::f(float)相互重载,而Base::g(void)被Derived::g(void)覆盖。

 

隐藏是指派生类的函数屏蔽了与其同名的基类函数,规则如下: 1) 如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。2) 如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。

 

比如,在下面的程序中:

 

#include <iostream.h>

 

class Base

{

public:

virtual void f(float x){ cout << "Base::f(float) " << x << endl; }

void g(float x){ cout << "Base::g(float) " << x << endl; }

void h(float x){ cout << "Base::h(float) " << x << endl; }

};

 

class Derived : public Base

{

public:

virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }//被继承之后,virtual 可有可无,但最好有。继承后,还是虚函数。

void g(int x){ cout << "Derived::g(int) " << x << endl; }

void h(float x){ cout << "Derived::h(float) " << x << endl; }

using Base::g;//这句话是用来引用父类中被隐藏的部分的。

};

 

通过分析可得:

 

1) 函数Derived::f(float)覆盖了Base::f(float)。

 

2) 函数Derived::g(int)隐藏了Base::g(float),注意,不是重载。

 

3) 函数Derived::h(float)隐藏了Base::h(float),而不是覆盖。

 

看完前面的示例,可能大家还没明白隐藏与覆盖到底有什么区别,因为我们前面都是讲的表面现象,怎样的实现方式,属于什么情况。下面我们就要分析覆盖与隐藏在应用中到底有什么不同之处。在下面的程序中bp和dp指向同一地址,按理说运行结果应该是相同的,可事实并非如此。

 

void main(void)

{

Derived d;

Base *pb = &d;

Derived *pd = &d;

// Good: behavior depends solely on type of the object

pb->f(3.14f); //运行结果: Derived::f(float) 3.14

pd->f(3.14f); //运行结果: Derived::f(float) 3.14

// Bad : behavior depends on type of the pointer

pb->g(3.14f); //运行结果: Base::g(float) 3.14

pd->g(3.14f); //运行结果: Derived::g(int) 3

// Bad : behavior depends on type of the pointer

pb->h(3.14f); //运行结果: Base::h(float) 3.14

pd->h(3.14f); //运行结果: Derived::h(float) 3.14

}

 

请大家注意,f()函数属于覆盖,而g()与h()属于隐藏。从上面的运行结果,我们可以注意到在覆盖中,用基类指针和派生类指针调用函数f() 时,系统都是执行的派生类函数f(),而非基类的f(),这样实际上就是完成的“接口”功能。而在隐藏方式中,用基类指针和派生类指针调用函数f()时,系统会进行区分,基类指针调用时,系统执行基类的f(),而派生类指针调用时,系统“隐藏”了基类的f(),执行派生类的f(),这也就是“隐藏”的由来。

 

重载(overload):这个好理解,在同个space域同名的。参数必须不同,有关virtual无关.

 

覆盖(override):同名字,同参数,有virtual,覆盖好理解比如show()函数,A派生了B,如果B中的show()覆盖了A中的show(),但B中仍然有两个show(),而不管是A类指针也好,B类对象调用也好,都只能调用B类自己的那个show();而从A类继承过来的show()函数真的就被覆盖了,没有了吗? 答案是不对的.这时可以在B类对象显示的调用A类继承过来的show();

 

程序代码:

 

#include <iostream> 

using namespace std; 

 

class A 

public: 

virtual void show() 

cout << a << endl; 

 

int a; 

}; 

 

class B:public A 

public: 

void show() 

A::show(); 

//显式地调用自己类中的 "由A类继承过来的show()函数" ,像这种直接显式指出某个类的某个函数时, 编译器处理方式是这样的: 首先在自己类中找有没有A::show(),如果找到,调用.不在继续在A类中找,如果找不到,则在显式指出的那个类中(即A类)调用那个函数. 这里当然是在B类中可以找到A::show() ,因为基类中指出了这个函数是virtual函数. 

int b; 

};

 

int main() 

A a; 

a.a = 3; 

a.show(); 

 

B b; 

b.b = 4; 

b.show(); 

b.A::show(); //显示的调用自己类中的 "由A类继承过来的show()函数"

 

return 0; 

}

 

总结:

 

通俗的讲B类还是有两个show(),只是调用由A继承过来的show()只能通过显式的调用方法 [类名::virtual函数名] 而不管是基类A的指针 (B b; A *p = &b; p->show())或者派生类的对象(B b; b.show()),都只能调用B类的自己本身存在的show()函数

 

隐藏hide:

 

1:同名同参无virtual

 

2:同名不同参不管有无virtual

 

程序代码:

 

class A 

public: 

void show() {}; //编号1 

void rose(int a) {} //编号2 

}; 

 

class B:public A 

public: 

void show() {}; //编号3 

void rose(int a, int b) {}; //编号4 

};

 

类B中的show()和rose()明显是隐藏了类A的show()和rose() 隐藏的理解: B类中其实有两个show(),两个rose(); 但为什么不叫重载呢?你会这样想,但我可以告诉你,因为类B中的两个show(),两个rose(),不是都可以被B类的对象调用的.

 

编号1和编号2,在类B中哪怕存在,但只能通过类A的指针调用,而不能通过B类对象调用,如:

 

程序代码:

 

A *p = new B; 

p->show(); 

p->rose(3); 

p->rose(3,5); //error

 

编号3和编程4,只能通过类B对象调用,而不能通过类A的指针调用,如:

 

程序代码:

 

B b; 

b.show(); 

b.rose(3,5); 

b.rose(4); //error

 

6. 用参数列表可以区分重载函数,为什么返回值却不能区分重载函数?

 

比如说有两个函数:int fun(); double fun(); 如果写fun();那么编译器就不知道该调用谁了。函数调用结束后才能确定返回值,但程序在调用函数时就需要明确知道调用哪一个重载的函数,这前后矛盾。

 

7. 派生类与基类之间的关系

 

派生类对象可以使用基类的方法,条件是方法在基类中没有被声明为私有的。基类指针可以在不进行显式类型转换的情况下指向派生类对象,基类引用可以在不进行显式类型转换的情况下引用派生类对象。不过,基类指针或引用只能用于调用基类方法,不能调用派生类的方法。通常C++要求引用和指针类型与赋给的类型匹配,但这一规则对继承来说是个例外。不过这种例外只是单向的,不可以将基类对象和地址赋给派生类引用和指针。

 

8. 静态联编和动态联编

 

程序调用函数时,将使用哪个可执行代码块呢?编译器负责回答这个问题。将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编。在C语言中,这非常简单,因为每个函数名都对应一个不同的函数。在C++中,由于函数重载的缘故,这项任务更复杂。编译器必须查看函数参数以及函数名才能确定使用哪个函数。然而,C/C++编译器可以在编译过程完成这种联编。在编译过程中进行联编被称为静态联编/绑定,又称为早期联编/绑定。不过,虚函数使这项工作变得更困难。因为使用哪个函数是不能在编译时确定的,因为编译器不知道用户将选择哪种类型的对象。所以,编译器必须生成能够在程序运行时选择正确的虚方法的代码,这被称为动态联编/绑定,又被称为晚期联编/绑定。

本文由威尼斯www.9778.com发布于编程人生,转载请注明出处:威尼斯正版官方网站C++中的基类与派生类

关键词:

Google C++ 编程风格指南:作用域

通常每一个  .cc  文件都有一个对应的  .h  文件. 也有一些常见例外,如单元测试代码和只包含  main()  函数的  .c...

详细>>

C++ 中三种正则表明式相比较

3、boost regex /* write by xingming * for:test boost regex * time:2012年10月23日11:35:33 * */#include iostream#include string#include sys/time.h#in...

详细>>

威尼斯正版官方网站new与malloc的10点区别

堆内存 vs. 内存池 Allocator类在“释放列表”为空时,能够从堆内存或者内存池中申请新内存。如果使用内存池,你必...

详细>>

【转】C# 中 10 个你真的应该学习(和使用!)的功能

如果你开始探索C#或决定扩展你的知识,那么你应该学习这些有用的语言功能,这样做有助于简化代码,避免错误,节...

详细>>