C++继承

先上一段代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#include<iostream>   using namespace std;   class Base{ public:     int a; protected:     int b; private:     int c; };   struct Derived:public Base{ };   int main(){     Derived inst;     cout<<sizeof(Base)<<endl;     cout<<sizeof(Derived)<<endl;     cout<<sizeof(inst)<<endl;     cout<<inst.a<<endl;     return 0; }

输出：

12
12
12
15487104

对应上面的代码，先啰嗦几个与“继承”无关的语法：struct可以继承自一个class；sizeof()可以施加在一个类型上面，也可以施加在一个对象上面；由于inst是局部变量，所以类中的普通类型数据成员是不被初始化的，所以输出a=15487104。

我们看到sizeof(Base)==sizeof(Derived)==12，可见Derived继承了Base的public、protected、private成员。

struct Derived:public Base{ public:     void func(){         cout<<b<<endl;     } };   int main(){     Derived inst;     inst.func();     return 0; }

一般在类外是不能访问protected成员的，所以在main()函数中调用cout<<inst.b;中会发生编译错误的，但是我们可以把对protected成员的访问封闭在一个public方法中，通过调用public方法来间接访问protected数据成员。

struct Derived:public Base{ public:     void func(){         cout<<c<<endl;     } };

上面代码会有编译错误，protected成员好歹在派生类中还可以访问，private成员在派生类中都不能访问。既然成员c在Derived中不能访问，那sizeof(Derived)又何苦要等于12呢？以Derived分配了3个int的空间，但其中一个int却是不可访问的，有什么意义呢？

（1）公有继承：基类成员保持自己的访问级别：基类的public成员在派生类中还是public，基类的protected成员在派生类中还是protected。

（2）受保护继承：基类的public和protected成员在派生类中成为protected成员。

（3）私有继承：基类的所有成员在派生类中成为private成员。

struct Derived:private Base{ };   class Grandson:public Derived{ public:     void func(){         cout<<a<<endl;     } };

上面的代码有编译错误，由于Derived私有继承自Base，所以a在Derived中已经是private了，在Grandson中不能访问Derived中的私有成员。 

struct Derived:private Base{ public:     using Base::b; protected:     using Base::a; };

由于Derived私有继承自Base，按说a、b、c在Derived中应该都是私有的，但通过上述方式，在Derived中b中公有的，a中受保护的。

struct Derived:Base

 Derived为struct时默认为公有继承。

class Derived:Base

Derived为class时默认为私有继承。

友元类可以访问private和protected成员数据，友元关系不能继承。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include<iostream>   using namespace std;   class Base{     friend class Frnd; private:     int a; };   class Derived:public Base{ };   class Frnd{ public:     void func(){         Base base;         cout<<base.a<<endl;　　　　//OK         Derived derived;         cout<<derived.a<<endl;　　　　//error     } };

虚函数

当父类中的某个函数标记为virtual时，子类中如果重载了该方法则自动也具有virtual属性，不管你是否使用了"virtual“关键字。比如下面的代码：

#include<iostream>   using namespace std;   class A{ public:     virtual void func(){         cout<<"A.func"<<endl;     } };   class B:public A{ public:     void func(){            //虽然没有显式写明virtual，但该函数依然是虚函数         cout<<"B.func"<<endl;     } };   class C:public B{ public:     virtual void func(){         cout<<"C.func"<<endl;     } };   int main(){     A *a=new A();     A *b=new B();     A *c=new C();     a->func();     b->func();     c->func();     return 0; }

输出：

A.func
B.func
C.func

内部类可以访问外部类的所有成员。

class Base{ public:     int a;     class Inner{     public:         void func(){             Base base;             cout<<base.c<<endl;         }     }; protected:     int b; private:     int c; };   int main(){     Base::Inner inst;     inst.func();     return 0; }

注意在main函数中访问Inner类时要加Base::前缀，另外Inner只有定义在Base的public域下时，在Base之外才可以访问Inner。

#include<iostream>   using namespace std;   class Base{ public:     Base(){         cout<<"Base construct"<<endl;     }     virtual void foo(){         cout<<"Base foo"<<endl;     }     ~Base(){         cout<<"Base destruct"<<endl;     } };   class Derived:public Base{ public:     Derived(){         cout<<"Derived construct"<<endl;     }     virtual void foo(){         cout<<"Derived foo"<<endl;     }     ~Derived(){         cout<<"Derived destruct"<<endl;     } };   int main(){     Base *inst=new Derived();       //调用Derived的构造函数，在此之前会调用Base的构造函数     inst->foo(); //调用Derived的foo方法     delete inst; //只调用了Base的析构函数 }

通常情况下Derived拥有比Base更多的数据成员，在Derived的析构函数中需要释放更多的资源，但是我们看到上面的代码中Base和Derived的构造函数都调用了，最后却只调用了Base的析构函数。解决方法：Base中使用虚的析构函数。

#include<iostream>   using namespace std;   class Base{ public:     Base(){         cout<<"Base construct"<<endl;     }     virtual void foo(){         cout<<"Base foo"<<endl;     }     virtual ~Base(){         cout<<"Base destruct"<<endl;     } };   class Derived:public Base{ public:     Derived(){         cout<<"Derived construct"<<endl;     }     virtual void foo(){         cout<<"Derived foo"<<endl;     }     ~Derived(){         cout<<"Derived destruct"<<endl;     } };   int main(){     Base *inst=new Derived();　　//调用Derived的构造函数，在此之前会调用Base的构造函数     inst->foo(); 　　//调用Derived的foo方法     delete inst; 　　//调用Derived的析构函数，在此之后会调用Base的析构函数 }

最佳实践：即便析构函数不做任何工作，继承层次的根类也应该定义一个虚析构函数。

class Base{ public:     double price(std::size_t) const =0; };

在函数形参表后面写上=0表示该函数为纯虚函数，含有一个或多个纯虚函数的类为抽象类，不能创建抽象类的实例。抽象类为后代提供了可以覆盖的接口。

void func(Base &base); Derived inst; func(inst);

当把基类对象传递给func()函数时，引用base直接绑定到inst对象，没有发生对象的复制，没有发生类型的转换，inst也没有发生任何改变不。

void func(Base base); Derived inst; func(inst);

此时情况完全不同，形参的类型是固定的，在编译和运行时都是基类类型对象，如果把派生类对象传递过去，则派生类对象中的基类部分会发生复制。

原文来自:博客园（华夏35度）http://www.cnblogs.com/zhangchaoyang 作者:Orisun