面向对象编程概述
继承(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(); //通过这个对象访问
}
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!!
Thinking!
没有机会做大事的人,是因为没有通过做好小事来证明自己的实力。放在越不起眼的地方,越要主动发光。在别人不敢委以重任之前,把小事做到极致,来证明你的实力。——可惜大多数人永远都想不明白这个道理,怨天尤人者居多,有的似乎明白了,又不去实践,所谓蹉跎岁月,想必就是如此。