【足迹C++primer】51、面向对象编程概述

2022-09-30 15:21:51

面向对象编程概述

继承（Inheritance）

class Quote
{
public:
    Quote(){cout<<"Quote的构造函数！"<<endl;}
    string isbn() const {cout<<"Quote的isbn()调用！"<<endl; string s="Quote,isbn"; return s;}
    virtual double net_price(size_t n) const {cout<<"虚函数！"<<endl; double d=1; return d;}   //虚函数，这个不同的类会定义自己不同的版本
};

//继承，如何继承？
class  Bulk_quote : public Quote    //Bulk_quote继承了Quote
{
public:
    Bulk_quote(){cout<<"Bulk_quote的构造函数！"<<endl;}
    double net_price(size_t) const override  {cout<<"这是继承过来的net_price在Bulk_quote实现！"<<endl; double d=2; return d;}  //继承的类必须重新声明虚函数，并实现自己的版本
    //override保留字表示当前函数重写了基类的虚函数。
    /*
    目的：1.在函数比较多的情况下可以提示读者某个函数重写了基类虚函数
    （表示这个虚函数是从基类继承，不是派生类自己定义的）；
    2.强制编译器检查某个函数是否重写基类虚函数，如果没有则报错。
    */
};
【足迹C++primer】51、面向对象编程概述

动态绑定

double print_total(ostream &os, const Quote &item, size_t n)
{
    //根据不同的对象来绑定到这个参数的类型
    //这里引用Quote::net_price 或 Bulk_quote::net_price
    double ret=item.net_price(n);
    os<<"ISBN: "<<item.isbn()   //调用 Quote::isbn
      <<" # sold: "<<n<<" total due: "<<ret<<endl;

    return ret;     //这里上面的Quote参数是可以接受Quote或者Bulk_quote类型的
}

void fun1()
{
    Quote basic;
    Bulk_quote bulk;
    print_total(cout, basic, 20 );
    print_total(cout, bulk, 20);
}

基类和派生类的定义

定义一个基类

class Quote2
{
public:
    Quote2()=default;
    Quote2(const string &book, double sales_price):bookNo(book), price(sales_price)
     {cout<<"Quote构造函数222"<<endl;}
    string isbn() const {return bookNo;}
    //返回指定数量的项目总销售价格
    //派生类将重写应用不同的折扣算法
    virtual double net_price(size_t n) const {return n*price;}
    virtual ~Quote2()=default;   //动态链接析构函数
private:
    string bookNo;  //这本书的isbn号
protected:
    double price=0.0;       //不打折的价格

};

Base classes ordinarily should define a virtual destructor. Virtual destructors
are needed even if they do no work.(献给爱装逼的朋友^_^)
基类通常应该定义一个虚析构函数。虚析构函数 即使他们不工作的需要。


定义一个派生类

class Bulk_quote2 : public Quote2
{
public:
    Bulk_quote2()=default;
    Bulk_quote2(const string &, double, size_t, double){cout<<"Bulk_quote2构造函数222"<<endl;}
    //重写虚函数
    double net_price(size_t) const override {cout<<"net_price(size_t) const override"<<endl;}
    //再次说明，请声明函数后一定要记得定义它，不然我这是出了各种莫名其妙的错误！
//    ~Bulk_quote2(){cout<<"~Bulk_quote2()"<<endl;}
private:
    size_t min_qty=0;
    double discount=0.0;
};

派生类中的虚函数
派生类的对象和导出到基类的转换

void fun2()
{
    Quote2 item;    //基类
    Bulk_quote2 bulk;   //派生类
    Quote2 *p=&item;
    p=&bulk;
    Quote2& r=bulk;
}

派生类构造函数

首先初始化基类，并派生类的成员 在它们的类中声明的顺序初始化。

class Bulk_quote3 : public Quote2
{
public:
    Bulk_quote3()=default;
    Bulk_quote3(const string & book, double p, size_t qty, double disc)
    : Quote2(book, p), min_qty(qty), discount(disc)
    {cout<<"Bulk_quote2构造函数222"<<endl;}
    //重写虚函数
    double net_price(size_t) const override;
    //再次说明，请声明函数后一定要记得定义它，不然我这是出了各种莫名其妙的错误！
//    ~Bulk_quote2(){cout<<"~Bulk_quote2()"<<endl;}
private:
    size_t min_qty=0;
    double discount=0.0;
};

使用派生类的基类的成员

不同的数量打折问题！！达到相应的数量才打折
double Bulk_quote3::net_price(size_t cnt) const
{
    if(cnt >= min_qty)
        return cnt*(1-discount)*price;
    else
        return cnt*price;
}

继承和静态成员

class Base
{
public:
    static void statmem(){cout<<"Base:static void statmem()"<<endl;}
};

class Derived : public Base
{
    void f(const Derived&);
};

void Derived::f(const Derived &derived_obj)
{
    Base::statmem();
    Derived::statmem();
    derived_obj.statmem();  //通过派生类对象访问
    statmem();              //通过这个对象访问
}

The All Code！！ 

/**
* 功能:面向对象编程概述
* 时间:2014年7月20日14:15:45
* 作者:cutter_point
*/

#include<iostream>
#include<string>

using namespace std;

/**
继承（Inheritance）
*/
class Quote
{
public:
    Quote(){cout<<"Quote的构造函数！"<<endl;}
    string isbn() const {cout<<"Quote的isbn()调用！"<<endl; string s="Quote,isbn"; return s;}
    virtual double net_price(size_t n) const {cout<<"虚函数！"<<endl; double d=1; return d;}   //虚函数，这个不同的类会定义自己不同的版本
};

//继承，如何继承？
class  Bulk_quote : public Quote    //Bulk_quote继承了Quote
{
public:
    Bulk_quote(){cout<<"Bulk_quote的构造函数！"<<endl;}
    double net_price(size_t) const override  {cout<<"这是继承过来的net_price在Bulk_quote实现！"<<endl; double d=2; return d;}  //继承的类必须重新声明虚函数，并实现自己的版本
    //override保留字表示当前函数重写了基类的虚函数。
    /*
    目的：1.在函数比较多的情况下可以提示读者某个函数重写了基类虚函数
    （表示这个虚函数是从基类继承，不是派生类自己定义的）；
    2.强制编译器检查某个函数是否重写基类虚函数，如果没有则报错。
    */
};

/**
动态绑定
*/
double print_total(ostream &os, const Quote &item, size_t n)
{
    //根据不同的对象来绑定到这个参数的类型
    //这里引用Quote::net_price 或 Bulk_quote::net_price
    double ret=item.net_price(n);
    os<<"ISBN: "<<item.isbn()   //调用 Quote::isbn
      <<" # sold: "<<n<<" total due: "<<ret<<endl;

    return ret;     //这里上面的Quote参数是可以接受Quote或者Bulk_quote类型的
}

void fun1()
{
    Quote basic;
    Bulk_quote bulk;
    print_total(cout, basic, 20 );
    print_total(cout, bulk, 20);
}

/**************************************
基类和派生类的定义
**************************************/

/**
定义一个基类
*/
class Quote2
{
public:
    Quote2()=default;
    Quote2(const string &book, double sales_price):bookNo(book), price(sales_price)
     {cout<<"Quote构造函数222"<<endl;}
    string isbn() const {return bookNo;}
    //返回指定数量的项目总销售价格
    //派生类将重写应用不同的折扣算法
    virtual double net_price(size_t n) const {return n*price;}
    virtual ~Quote2()=default;   //动态链接析构函数
private:
    string bookNo;  //这本书的isbn号
protected:
    double price=0.0;       //不打折的价格

};

/*
Base classes ordinarily should define a virtual destructor. Virtual destructors
are needed even if they do no work.(献给爱装逼的朋友^_^)
基类通常应该定义一个虚析构函数。虚析构函数 即使他们不工作的需要。
*/

/**
定义一个派生类
*/
class Bulk_quote2 : public Quote2
{
public:
    Bulk_quote2()=default;
    Bulk_quote2(const string &, double, size_t, double){cout<<"Bulk_quote2构造函数222"<<endl;}
    //重写虚函数
    double net_price(size_t) const override {cout<<"net_price(size_t) const override"<<endl;}
    //再次说明，请声明函数后一定要记得定义它，不然我这是出了各种莫名其妙的错误！
//    ~Bulk_quote2(){cout<<"~Bulk_quote2()"<<endl;}
private:
    size_t min_qty=0;
    double discount=0.0;
};

/**
派生类中的虚函数
派生类的对象和导出到基类的转换
*/
void fun2()
{
    Quote2 item;    //基类
    Bulk_quote2 bulk;   //派生类
    Quote2 *p=&item;
    p=&bulk;
    Quote2& r=bulk;
}

/**
派生类构造函数
*/

/*
首先初始化基类，并派生类的成员 在它们的类中声明的顺序初始化。
*/
class Bulk_quote3 : public Quote2
{
public:
    Bulk_quote3()=default;
    Bulk_quote3(const string & book, double p, size_t qty, double disc)
    : Quote2(book, p), min_qty(qty), discount(disc)
    {cout<<"Bulk_quote2构造函数222"<<endl;}
    //重写虚函数
    double net_price(size_t) const override;
    //再次说明，请声明函数后一定要记得定义它，不然我这是出了各种莫名其妙的错误！
//    ~Bulk_quote2(){cout<<"~Bulk_quote2()"<<endl;}
private:
    size_t min_qty=0;
    double discount=0.0;
};

/**
使用派生类的基类的成员
*/
//不同的数量打折问题！！达到相应的数量才打折
double Bulk_quote3::net_price(size_t cnt) const
{
    if(cnt >= min_qty)
        return cnt*(1-discount)*price;
    else
        return cnt*price;
}

/**
继承和静态成员
*/
class Base
{
public:
    static void statmem(){cout<<"Base:static void statmem()"<<endl;}
};

class Derived : public Base
{
    void f(const Derived&);
};

void Derived::f(const Derived &derived_obj)
{
    Base::statmem();
    Derived::statmem();
    derived_obj.statmem();  //通过派生类对象访问
    statmem();              //通过这个对象访问
}


int main()
{
    cout<<">>------------------------------fun1-----------------------------------<<"<<endl;
    fun1();
    cout<<">>------------------------------fun2-----------------------------------<<"<<endl;
    fun2();


    return 0;
}

Show The Result！！

【足迹C++primer】51、面向对象编程概述


Thinking！

没有机会做大事的人，是因为没有通过做好小事来证明自己的实力。放在越不起眼的地方，越要主动发光。在别人不敢委以重任之前，把小事做到极致，来证明你的实力。——可惜大多数人永远都想不明白这个道理，怨天尤人者居多，有的似乎明白了，又不去实践，所谓蹉跎岁月，想必就是如此。



【足迹C++primer】51、面向对象编程概述

上一篇：iOS -转载-根据字母排序


下一篇：Java中正则表达式常用方法汇总