C++中的基类和派生类

转载自：http://www.cnblogs.com/sujz/archive/2011/05/12/2044365.html

派生类的继承方式总结：

继承方式	说明
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++编译器可以在编译过程完成这种联编。在编译过程中进行联编被称为静态联编/绑定，又称为早期 联编/绑定。不过，虚函数使这项工作变得更困难。因为使用哪个函数是不能在编译时确定的，因为编译器不知道用户将选择哪种类型的对象。所以，编译器必须生 成能够在程序运行时选择正确的虚方法的代码，这被称为动态联编/绑定，又被称为晚期联编/绑定。