C++之继承

#include <iostream>
#include <string>

using namespace std;
//基类
class Item_base
{
public:
    Item_base(const string &book=" ",double sale_price=0.0):
        isbn(book),
        price(sale_price){}
    string book() const
    {
            return isbn;
    }
    //虚函数可以被子类重新定义
    virtual double net_price(size_t n)const
    {
        return n*price;
    }
private:
    string isbn;
protected:
    double price;
};
//继承 子类
class Bulk_item : public Item_base
{
public:
    Bulk_item(const string &book=" ",double sale_price=0.0,size_t qty=0,double disc_rate=0.0):
        Item_base(book,sale_price), //先初始化基类
        min_qty(qty),
        discount(disc_rate){} //初始化子类
    //虚函数进行重写
    double net_price(size_t cnt)const
    {
        if(cnt>=min_qty)
        {
            return cnt*(1-discount)*price;
        }else{
            return cnt*price;
        }
    }
private:
    size_t min_qty;
    double discount;
};

//多态
void print_total(ostream &o,Item_base* it,size_t n)
{
    o<<"ISBN"<<it->book()<<"=="<<"sold"<<n<<"=="<<"price"<<it->net_price(n)<<endl;
}
//
void print_total_1(ostream &o,Item_base it,size_t n)
{
    o<<"ISBN"<<it.book()<<"=="<<"sold"<<n<<"=="<<"price"<<it.net_price(n)<<endl;
}
//
void print_total_2(ostream &o,Item_base& it,size_t n)
{
    o<<"ISBN"<<it.book()<<"=="<<"sold"<<n<<"=="<<"price"<<it.net_price(n)<<endl;
}
//=============================================================

//派生类的构造函数
class Base1
{
public:
    Base1(int i)
    {
        b1=i;
        cout<<"base1的构造函数被调用"<<endl;
    }
    void Print()const
    {
        cout<<b1<<endl;
    }
private:
    int b1;
};

class Base2
{
public:
    Base2(int i)
    {
        b2=i;
        cout<<"base2的构造函数被调用"<<endl;
    }
    void Print()const
    {
        cout<<b2<<endl;
    }
private:
    int b2;
};

class Base3
{
public:
    Base3()
    {
        b3=0;
        cout<<"base3的构造函数被调用"<<endl;
    }
    void Print()const
    {
        cout<<b3<<endl;
    }
private:
    int b3;
};
class Member
{
public:
    Member(int i)
    {
        m=i;
        cout<<"Member的构造函数被调用"<<endl;
    }
    int GetM()
    {
        return m;
    }
private:
    int m;
};
class Derive : public Base2,public Base1,public Base3
{
public:
    Derive(int i,int j,int k,int l);
    void Print();
private:
    int d;
    Member mem;
};
Derive::Derive(int i,int j,int k,int l):Base1(i),Base2(j),mem(k)
{
    d=l;
    cout<<"派生类的构造函数被调用了"<<endl;
}

void Derive::Print()
{
    Base1::Print();
    Base2::Print();
    Base3::Print();
    cout<<mem.GetM()<<endl;
    cout<<d<<endl;
}
//============================================


int main()
{
    //继承测试
//    Item_base item1("0-120324-k",20.00);
//    Bulk_item item2("0-120324-k",20.00,10,0.12);
//    cout<<item2.book()<<'-'<<item2.net_price(20)<<endl;
    //多态
//    Item_base* books[5];
//    books[0]=new Item_base("0-123-456-1",10.0);
//    books[1]=new Bulk_item("0-123-456-2",20.0,6,0.05);
//    books[2]=new Item_base("0-123-456-3",30.0);
//    books[3]=new Bulk_item("0-123-456-4",40.0,4,0.05);
//    books[4]=new Item_base("0-123-456-5",50.0);
//
//    int num[5];
//    num[0]=2;
//    num[1]=9;
//    num[2]=5;
//    num[3]=4;
//    num[4]=3;
//
//    for(int i=0;i<5;i++)
//    {
//        print_total(cout,books[i],num[i]);
//    }

    //派生类的构造函数
    //构造子类的对象必须先构造基类的对象然后是成员对象的构造函数最后构造自己的成员函数 只有先初始化基类对象才能子类使用
    //析构函数是正好相反的
//    Derive d1(1,2,3,4);
//    d1.Print();


    //转换与继承
    //基类转换成派生类是自动的 派生类转换成基类是强制的
//    Item_base item1("0-120324-k",20.00);
//    Bulk_item item2("0-120324-k",20.00,10,0.12);
//    print_total_1(cout,item1,10);
//    //派生类自动转换成基类 但是调用的方法为基类的方法没有打折 有问题
//    print_total_1(cout,item2,10);
//    print_total(cout,&item1,10);
//    //指针转换调用方法没问题 可以打折
//    print_total(cout,&item2,10);
//    print_total_2(cout,item1,10);
//    //引用转换调用方法没问题 可以打折
//    print_total_2(cout,item2,10);

    //友元与继承  友元关系不能继承，要明确的授予友元关系

    return 0;
}