c++学习笔记十四

 继承


  1 类和面向对象编程
  2 类的继承
       继承和聚合
       从基类中派生新类   头文件 Box.h示例代码如下:
       #ifndef BOX_H
       #define BOX_H 
       
       class Box{
        //构造器
        public:
 Box(double lv=1.0,double wv=1.0,double hv=1.0);


        private:
          double length;
          double width;
          double height;
       };
       #endif
       实现文件Box.cpp如下:
       #include "box.h"
       
       Box::Box(double lv,double wv,double hv):length(lv),width(wv),height


(hv){}
 
       定义一个carton是Box的派生类，Carton.h头文件的示例代码如下:
        #ifndef CARTON_H
        #define CARTON_H
        #include "Box.h"
 
        class Carton: public Box{  //public是基类访问指定符
          
          public:
             Carton(const char* pStr="Cardboard");//构造器
            ~Carton();//析构函数
     
          //成员变量
          private:
             char * pMaterial;//合成材料
        };
        #endif
       
         实现文件Carton.cpp，示例代码如下：
         #include "Carton.h"
         #include <cstring>
 
         //构造函数
         Carton::Carton(const char* pStr){
             pMaterial=new char[strlen(pStr)+1]; //分配空间
             std::strcpy(pMaterial,pStr);    //复制内容 
         }
         
         //析构函数
         Carton::~Carton(){
           delete[] pMaterial;
         }
        
         使用派生类
        #include <iostream>
        #include "Box.h"
        #include "Carton.h"
        using std::cout;
        using std::endl;


        int main(){
           Box myBox(40.0,30.0,20.0);
           Carton myCarton;
           Carton candyCarton("Thin cardboard");


           cout<<endl
               <<"myBox occupies"<<sizeof myBox<<"bytes"<<endl;
           cout<<"myCarton occupies"<<sizeof myCarton<<"bytes"<<endl;
           cout<<"candyCarton occupies"<<sizeof candyCarton<<"bytes"<<endl;
           
 //以下两句在编译时会发生错误,因为length是Box的私有成员
 // myBox.length=10.0;  
           //candyCarton.length=10.0;


           return 0;
        }
        注: 其中每个数据成员占8个字节


       
     3 继承下的访问控制
         Carton.h头文件的示例代码如下 ：
        #ifndef CARTON_H
        #define CARTON_H
        #include "Box.h"
 
        class Carton: public Box{  //public是基类访问指定符
          
          public:
             Carton(const char* pStr="Cardboard");//构造器
            ~Carton();//析构函数


 //成员方法
           double volume() const;
     
          //成员变量
          private:
             char * pMaterial;//合成材料
        };
        #endif


         实现文件Carton.cpp，示例代码如下：
         #include "Carton.h"
         #include <cstring>
 
         //构造函数
         Carton::Carton(const char* pStr){
             pMaterial=new char[strlen(pStr)+1]; //分配空间
             std::strcpy(pMaterial,pStr);    //复制内容 
         }
         
         //析构函数
         Carton::~Carton(){
           delete[] pMaterial;
         }
 
         //成员方法
         double Carton::volume() const{
            return length*width*height;
         }




        基类成员函数
        
        基类头文件 Box.h
        class Box{
           public:
               Box(double lv=1.0,double wv=1.0,double hv=1.0);
           double volume() const;
        
           private:
               double length;
               double width;
               double height;
        };
        实现文件Box.cpp
          #include "Box.h"
         
          //构造函数
          Box::Box(double lv,double wv,double hv):length(lv),width


(wv),height(hv){}
          double Box::volume() const{
             return length*width*height;
          }
  
          在派生类中使用基类函数
          #include <iostream>
          #include "Box.h"
          #include "Carton.h"
          using std::cout;
          using std::endl;


          int main(){
    //实例化对象
            Box myBox(40.0,30.0,20.0);
           Carton myCarton;
           Carton candyCarton("Thin cardboard");
        
           cout<<endl
               <<"myBox volume is"<<myBox.volume()<<endl;
           cout<<"myCarton volume is"<<myCarton.volume<<endl;
           cout<<"candyCarton volume 


is"<<candyCarton.volume<<"bytes"<<endl;


          } 


      4 把类的成员声明为protected 
          这样派生类可以访问其成员


      5 派生成员的访问级别 public protected和private (默认) 共有9种不同的组


合
       访问级别如下图所示


         ============                         ===============
          公共的基类 ------------------------>   派生类
         ============                         ===============
           公共成员  ------------------------>     公共
         ============                         ===============
         受保护的成员------------------------>   受保护的
         ============                         ===============
           私有成员  ------------------------> 继承但不能访问
         ============                         ===============






============                         ===============
         受保护的基类 ----------------------->   派生类
         ============                         ===============
           公共成员  ------------------------>  受保护的
         ============                         ===============
         受保护的成员------------------------>  受保护的
         ============                         ===============
           私有成员  ------------------------> 继承但不能访问
         ============                         ===============








============                         ===============
         私有的基类 ------------------------>   派生类
         ============                         ===============
           公共成员  ------------------------>   私有
         ============                         ===============
         受保护的成员------------------------>   私有
         ============                         ===============
           私有成员  ------------------------> 继承但不能访问
         ============                         ===============


          在类层次中使用访问指定符
          改变继承成员的访问指定符 示例代码如下：
        Box.h头文件
class Box{
           public:
               Box(double lv=1.0,double wv=1.0,double hv=1.0);
           double volume() const;
        
           private:
               double length;
               double width;
               double height;
        };


        Box.cpp实现文件            
          #include "Box.h"
         
          //构造函数
          Box::Box(double lv,double wv,double hv):length(lv),width


(wv),height(hv){}
          double Box::volume() const{
             return length*width*height;
          }
 
         使用以下方法将派生类中的函数改为公共成员
          class Package: private Box{
             public:
                using Box::volume;
    };
        
       6  派生类中的构造函数操作
          调用基类的构造函数
          
          class Carton:public Box{
              //调用基类默认构造函数
              Carton(const char * pStr ="Cardboard");
              Carton(double lv,double wv,double hv,const char * 


pStr="Cardboard");
 
              //析构函数
              ~Carton();
 
              //成员方法
              double volume() const;
 
              protected: 
                  char * pMaterial;
          } 
        
           实现文件Carton.cpp
           #include "Carton.h"
           #include <cstring>
           #include <iostream>  
           
            using std::cout;
            using std::endl;
            //构造器
            Carton::Carton(const char * pStr){
                pMaterial=new char[strlen(pStr)+1];//分配空间
                std::strcpy(pmaterial,pStr);
                cout<<"Carton constructor 1"<<endl;
            }
          
            Carton::Carton(double lv,double wv,double hv,const char * 


pStr):Box(lv,wv,hv){
                  pMaterial=new char[strlen(pStr)+1];
                  std::strcpy(pMaterlal,pStr);
                  cout<<"Carton constructor 2"<<endl;
            }
 
            Carton::~Carton(){
               delete[] pMaterial;
            }


            double Carton::volume() const{
               return length*width*height;
            }


           在程序实例化的时候,编译器会首先调用Box的构造器


           派生类中的副本构造函数
            Box myBox(2.0,3.0,4.0);
            Box copyBox(myBox);
            需要在基类中添加一个副本构造函数(副本构造参数指定为引用) Box.h 


中添加如下代码
             Box::Box(const Box & aBox):length(aBox.length),width


(aBox.width),height(aBox.height){
                 cout<<""<<endl;
             }
            在Carton.h中添加
             Carton(const Carton & aCarton);//副本构造函数

            派生类中也要添加自已的构造函数,在Carton.cpp中添加如下：
            Carton::Carton(const Carton & aCarton):Box(aCarton){
                pMaterial=new char[strlen(aCarton.pMaterisl)+1];//分配空间
                strcpy(pMaterial,aCarton.pMaterial) ;              


                cout<<"Carton copy constructor"<<endl;
            }
         
        7 继承中的析构函数 (在派生类对象超出作用域，或位于自由存储区时，必


须要释放他)    先调用派生类中的析构函数，后调用基类中的析构函数
        8 重复的成员名
          示例代码如下：
           class Base{
               //构造函数
               public:
                  Base(int number=10){value=number;}
               
               //数据成员
               protected:
                  int value;
           } 
           派生类Derived
           class Derived:public Base{ 
              public:
                 Derived(int number=20){value=number;}
                 int total() const;
           
              protected:
                 int value; //定义了重复成员名
           } 
          使用时必需指定其作用域(使用基类名和作用域解析运算符) 示例代码如下


:
            int Derived::total() const{
                return value+Base::value;
            }


          重复的函数成员名
            第一种情况:函数名相同，但参数列表不同
              class Base{
                public:
                   void doThat(int arg);
           ...
               };
              
               class Derived::public Base{
                   public:
                      void doThat(double arg);
                      using Base::doThat();
                          ...
                };
            第二种情况：所有方面都相同
              Derived object;
              object.Base::doThat(3);//调用基类的函数
       
          9 多重继承
             派生类可以有任意多个直接基类（这个跟java有点不同）
             多个基类,示例代码如下：
               class CerealPack:public Carton,public Contents{
                   ...
               }
             继承成员的模糊性
          
       头文件的定义如下========================================
               #ifndef BOX_H
               #define BOX_H 
       
               class Box{
                 
                   public:
             Box(double lv=1.0,double wv=1.0,double hv=1.0); //构


造器
                      Box(const Box & aBox);//副本构造器
                       
                       //析构函数
                       ~Box();
 
                   private:
                      double length;
                      double width;
                      double height;
               };
               #endif
               ==========================================================
               实现文件
               #include "Box.h"
               #include <iostream>
               using std::cout;
               using std::endl;
                
      //默认构造器
               Box::Box(double lv,double wv,double hv):length(lv),width


(wv),height(hv){
                 cout<<"Box constructor"<<endl;
               } 
   
               //副本构造成器
               Box::Box(const Box & aBox):length(lv),width(wv),height(hv){
                  cout<<"Box copy constructor called"<<endl;
               }
 
               //析构函数
               Box::~Box(){
                 cout<<"Box destructor"<<endl;
               }
               
               //成员方法
               double Box::volume() const{
                   return length*width*height;
               }
               ===========================================================
               以下是派生类 
                头文件Carton.h
                #ifndef CARTON_H
                #define CARTON_H
                #include "Box.h"
       
                class Carton: public Box{
                    //构造器
                    pulbic : 
                       Carton(double lv=1.0,double wv=1.0,double 


hv=1.0,const char * pStr="Cardboard",double dense=0.125,double thick=0.2);
 
                    //析构函数
                    ~Carton(); 
                
                    double getWeight() const;
                    
                    //成员变量
                    char * pMaterial;
                    double thickness; //厚度
                    double density; //密度
                };
                #endif
               ==========================================================
                实现文件Carton.cpp
                #include "Carton.h"
                #include <cstring>
                #include <iostream>
                using std::cout;
                using std::endl;


                //构造器
               Carton:: Carton(double lv,double wv,double hv,const char * 


pStr,double dense,double thick):Box(lv,wv,hv),density(dense),thisckness


(thick){
               pMaterial =new char[strlen(pStr)+1];//分配空间
               strcpy(pMaterial,pStr);
               cout<<"Carton constructor"<<endl;          
               }
               
               //析构函数
               Carton::~Carton(){
                   cout<<"Carton destructor"<<endl;
    delete[] pMaterial;
               }


               //取得重量
 
               double Carton::getWeight() const{
                    return 2*(length*width+width*height+height*length)


*thickness*density;
               }
               ============================================================
              Contents.h头文件
              #ifndef CONTNETS_H
              #define CONTENTS_H
  
              class Contents{
                  //构造器
                  public:
                     Contents(const char * pStr="cereal",double 


weight=0.3,double vol=0);
                     
                  //析构函数
                  ~Contents();
                  double getWeight() const;//取得重量
                  
                  //成员变量
                    char* pName;
                    double volume;
                    double unItweight;       
              };
              #endif
            ==============================================================
            Contents.cpp实现文件
             #include "Contents.h"
             #inlcude <cstring>
             #include <iostream>
             using std::cout;
             using std::endl;  


             //构造器
             Contents::Contents(const char* pStr,double weight,double 


vol):unitweight(weight),volume(vol){
             pName=new char[strlen(pStr)+1];
             std:strcpy(pName,pStr);
             cout<<"Contents constructor"<<endl;        
             }
             
             //析构函数
             Contents::~Contents(){
                   delete[] pName;
                   cout<<"Contents destructor"<<endl;
             }


             //取得重量
             double Contents::getWeight() const{
                return volume*unitweight;
             }
             ============================================================
             现在把Carton和Contents类作为公共基类
              CerealPack.h 头文件 
              #ifndef CERALPACK_H
              #define CERALPACK_H
              #include "Carton.h"
              #include "Contents.h"
              //CerealPack是carton和contents 的派生类
              class CerealPack:public Carton,public Contents{
                  //构造器
                  public:
                     CerealPack(double length,double width,double 


height,const char * cerealType);
                  
                  //析构函数
                  ~CerealPack();
              };
              #endif
             ==============================================================
              CerealPack.cpp实现文件如下
              #include <iostream>
              #include "Carton.h"
              #include "Contents.h"
              #include "Cerealpack.h"
               
              using std::cout;
              using std::endl;
              CerealPack::CerealPack(double length,double width,double 


height,const char * cerealType):Carton


(length,width,height,"cadboard"),Contents(cerealType){
                 cout<<"CerealPack constructor"<<endl;
                 Contents::volume=0.9*Carton::volume();
              }
             =============================================================
             使用多重继承 示例代码如下:
             #include <iostream>
             #include "CerealPack.h"
             using std::endl;
             using std::cout;
       
              int main(){
                 CerealPack packofFlakes(8.0,3.0,10.0,"Cornflakes");
         
                 
                 cout<<endl
                     <<"packofFlakes volume is"
                     <<packofFlakes.Carton::volume()
                     <<endl;
       
                 cout<<endl 
                     <<"packofFlakes weight is"
                     


<<packofFlakes.Crton::getWeight+packofFlakes.Contents::getWeight()
                     <<endl; 
                 return 0;
              }
             
             重复的继承


             虚基类 示例代码如下：(基类应只出现一次)
             class Contents:public virtual Comon{
                    ...
             };
             
             class Box:public virtual Common{
                    ...
             };
           
             ==========================================================
             class Freebie:public Common{ 
                  ...
              };
             
             class cerealPack:pulbic Carton,public Contents,publicFreebie{
                  ...
             };
             如果Common也声明为Freebie的虚基类，CerealPack类就只能继承


Common类型的一个子对象
            
            10 在相关的类类型之间的转换
              把派生类转换为基类类型，示例代码如下：
              Carton aCarton(40,50,60,"fiberboard"); 
              Box aBox;
              aBox=aCarton;