18.类继承

#include "baseclass.hpp"
#include "publicclass.hpp"

int main()
{

{
    base_class base1;
    public_class pub1(1,2,base1);
    base_class base2=public_class::base_class();
    //基类指针和引用可在不显式转换下指向派生类对象
    //基类指针和引用只能调用基类方法； 
    pub1.base_show(1);//派生类对象可以使用 基类的公有方法 
    pub1.callprotected();
}
    cout<<"-------------------------------------------------\n";
    base_class *bapr=new public_class(0,0,0,0);

    delete bapr;//这里调用了base析构，实际是pub对象 
}
//构造函数不能是虚函数
//析构函数应该是虚函数，除非不是基类
//友元不能是虚函数


//为什么定义虚析构？
/*使用delete释放new分配的对象，值根据指针类型调用析构函数，这会导致，对象数据没有被释放，所以应该定义虚析构
即使析构不做任何事，这样delete释放对象，先调用对象类型析构函数，再调用基类析构函数 
*/ 

/*继承类型：公有继承 私有继承 保护继承
公有继承  派生类公有 继承 基类公有；        is-a 
私有继承  派生类私有 继承 基类公有、保护；  has-a 
保护继承  派生类保护 继承 基类公有、保护；  has-a  
*/
/*
更多类的使用方法
 虚基类 继承关键词前加virtual
 多重继承  MI
 嵌套类 
*/

#ifndef __baseclass_hh
#define __baseclass_hh
#include "iostream"
    using namespace std;
class base_class
{

    private :
        int a;
        int b;
    protected://保护数据，对外保护，对派生类不保护
        int IamIsProtectedDate; 
    public:
        base_class(void) {  a=b=0;
        cout<<"create base object\n";
        };
        base_class(int a_,int b_) { a=a_;
        b=b_;
        cout<<"create base object\n";
        };
        void base_show(void)
        {
            cout<<"this is base fuc\n";
        }
        virtual void base_show(int arg);//虚方法， 使派生类可以重定义
        virtual ~base_class(void);//通常要为基类声明一个虚析构函数 
        virtual void base_show(int arg1,int arg2)  =0;//后缀表示纯虚函数，即基类不定义函数 ，这个用于抽象基类 
};
void base_class::base_show(int arg)
{
    if(arg)
        cout<<"this base virtual fuc\n";
};
 base_class::~base_class(void)
{
    cout<<"这是base析构\n";
} 

#endif

 #ifndef __publicclass_h
 #define __publicclass_h
 #include "baseclass.hpp"
 #include "iostream"
 //publicclass 是 baseclass的派生类
 //派生类继承了基类的实现，继承了基类的接口
 //派生类需要自己的构造函数，可以添加额外的数据

 class public_class : public base_class   //公有继承  
 {
    private:
        int c;
        int d;  
    public:
        void show(void) {std::cout<<c<<std::endl;
        };
        public_class(int c,int d,int a,int b);
        public_class(int c,int d,base_class & tp);//第二种 
        virtual void base_show(int arg);//虚方法，派生类可以重定义
        ~public_class();
        void callprotected()
        {
            cout<<"我访问基类protected数据~ :"<<IamIsProtectedDate<<endl;
        };
 };
 public_class::~public_class()
 {
    cout<<"这时派生类析构\n";
 };

 public_class::public_class(int c,int d,int a,int b):base_class(a,b)//给基类初始化，不写则为默认初始化;会在创建派生类前给基类初始化 
 {
    c=d=0;
    cout<<"create public_class\n";
 };
  public_class::public_class(int c,int d,base_class & tp):base_class(tp)//给基类初始化，不写则为默认初始化;会在创建派生类前给基类初始化 
 {
    c=d=0;
        cout<<"create public_class\n";
 };
 void public_class::base_show(int arg)
 {
    if(arg)
        cout<<"this is virtual fuc from base\n";
 }






 #endif