C++ Primer复习和学习笔记第十五章面向对象编程

最新推荐文章于 2021-06-02 19:36:04 发布

yangxuefeng09

最新推荐文章于 2021-06-02 19:36:04 发布

阅读量523

点赞数

分类专栏： C++ Primer 学习和复习笔记文章标签： c++ 编程

本文链接：https://blog.csdn.net/yangxuefeng09/article/details/43061613

版权

C++ Primer 学习和复习笔记专栏收录该内容

19 篇文章 0 订阅

订阅专栏

#include "D:\C++WORK\main.h"//派生类和基类的默认参数的问题

class Item_base
{
public:
	string _book;
	double _sales_price;
public:
	Item_base(const string &book="Item_base",double sales_price= 1.0 ):_book(book),_sales_price(sales_price){}
};

class Bulk_item :public Item_base
{
public:
	size_t min_qty;
	double discount;
public:
	Bulk_item(const string &book="Bulk_item",double sale_price=2.0,size_t qty=0,double disc_rate=0.0)\
		:Item_base(book,sale_price),min_qty(qty),discount(disc_rate){}
};

int main(int argc,char * argv[])
{
	Item_base  item;
	cout<<item._book<<"      "<<item._sales_price<<endl;

	Bulk_item  buitem;
	cout<<buitem._book<<"   "<<buitem._sales_price<<"    "<<buitem.discount<<"    "<<buitem.min_qty<<"   "<<endl;

	Item_base  * pitem = &buitem;
	cout<<pitem->_book<<"   "<<pitem->_sales_price<<"    "<<pitem->discount<<"    "<<pitem->min_qty<<"   "<<endl;
	//非虚函数  编译时候确定  pitem->discount<<"    "<<pitem->min_qty<<  这两句是无法打印出来的。
	return 0;		
}

#include "D:\C++WORK\main.h"

class base 
{
public:
	int add(int add1,int add2) {  return add1 + add2 ;} 
	double add(double add1,double add2) {  return add1 + add2 ;} 
	float add(float add1,float add2) {  return add1 + add2 ;} 
};

class derived1:public base
{
public:
	/*如果我在这个derived中只要定义了一个add函数，那么就屏蔽了所有基类中的add函数
	比如，如果我要写	int result = d.add(1,2);那么就会发生错误，但是如果是
	int result = d.add(1,2,3);那么就是可以运行的*/
	int add(int add1,int add2 ,int add3) { return  add1+add2+add3 ;}
	/*所以通过这段代码，我们可以看出来，如果你想使用基类中的所有的重载版本的函数
	[1]在派生类中，不要重新定义而是一直的直接使用基类中的函数[2]把基类中的每一个函数全部重载了。*/
};


class  derived2:public base
{
public:
	/*这里我们使用了using声明，这样，我们就能把基类的所有的重载函数全部的添加进来
	然后我们在实现一个我们在派生类中需要使用的特殊的add函数，这样就既能使用基类中的重载函数
	也能使用我们派生类中的重载函数了*/
	using base::add;
	int add(int add1,int add2 ,int add3) { return  add1+add2+add3 ;}
};
int main(int argc,char * argv[])
{
	derived1 d1;
	int result1 = d1.add(1,2,3);
	cout<<result1<<endl;

	derived2 d2;
	int result2 = d2.add(1,2,3);
	cout<<result2<<endl;

	result2 = d2.add(1,2);
	cout<<result2<<endl;

	return 0;		
}

/*下面的代码是第十五章，15-8节    511页面的题目15--35  使用句柄，综合性较强的题目。编写自己的compare函数和Basket类版本并使用它们管理销售*/

//Sales_item类的头文件-------------------------------<span style="font-family: Arial, Helvetica, sans-serif;">"Sales_item.h"</span>

#ifndef SALESITEM_H
#define SALESITEM_H
#include "Item.h"

class  Sales_item
{
public:
	Sales_item():p(0),use(new size_t(1)){}

	Sales_item(const Item_base& item):p(item.clone()),use(new size_t(1)){}

	Sales_item(const Sales_item &i):p(i.p),use(i.use){ ++*use; }

	~Sales_item() { decr_use();}

	Sales_item& operator=(const Sales_item &);

	const Item_base *operator->()const
	{
		if (p)
		{
			return p;
		} 
		else
		{
			throw logic_error("unbound  Sale_item");
		}
	}

	const Item_base & operator*()const
	{
		if (p)
		{
			return *p;
		} 
		else
		{
			throw logic_error("unbound  Sales_item");
		}
	}
private:
	Item_base *p;
	size_t *use;
	void decr_use()
	{
		if (--*use==0)
		{
			delete p;
			delete use;
		}
	}
};

#endif

#include "Sales_item.h"---------------------------------------<span style="font-family: Arial, Helvetica, sans-serif;">"Sales_item.cpp"</span>


Sales_item & Sales_item::operator =(const Sales_item &rhs)
{
	++*rhs.use;
	decr_use();
	p=rhs.p;
	use=rhs.use;
	return *this;
}

#ifndef ITEM_H<span style="font-family: Arial, Helvetica, sans-serif;">---------------------------------------</span><span style="font-family: Arial, Helvetica, sans-serif;">"Item.h"</span>

#define ITEM_H
#include "D:\C++WORK\main.h"
//不使用折扣策略的基类
class Item_base
{
public:
	Item_base(const std::string &book="",double sales_price=0.0):isbn(book),price(sales_price){}

	string book()const
	{
		return isbn;
	}
//返回特定购书量的总价格
//派生类将重载该函数以应用不同的价格策略
	virtual double net_price(size_t n)const
	{
		return n*price;
	}
	virtual Item_base * clone()const
	{
		return new Item_base(*this);
	}
	virtual ~Item_base(){}

protected:
	double price;
private:
	string isbn;
};

//保存折扣率和可实行折扣策略的数量
//派生类将使用这些数据实现定价策略
class Disc_item:public Item_base
{
public:
	Disc_item(const string &book="",double sales_price =0.0,size_t qty=0,double disc_rate=0.0):Item_base(book,sales_price),quantity(qty),discount(disc_rate){}

	double net_price(size_t ) const = 0;

	pair<size_t,double>  discount_policy()const
	{
		return make_pair(quantity,discount);
	}
protected:
	size_t quantity;
	double discount;
};

class Bulk_item:public Disc_item
{
public:
	Bulk_item(const string & book =" ",double sales_price=0.0,size_t qty=0,double disc_rate=0.0):Disc_item(book,sales_price,qty,disc_rate)
	{

	}
//重定义基类版本以实现批量购买折扣策略
//若购买量高于下限，则使用折扣价格
	  double net_price(size_t  cnt)const
	  {
		  if (cnt>=quantity)
		  {
			  return cnt*(1-discount)*price;
		  } 
		  else
		  {
			  return cnt *price;
		  }
	  }

	  virtual Bulk_item * clone()const
	  {
		  return new Bulk_item (*this);
	  }
};
//有限折扣类
class  Lds_item:public Disc_item
{
public:
	Lds_item(const string & book= " " ,double sales_price=0.0,size_t qty=0,double disc_rate=0.0):Disc_item(book,sales_price,qty,disc_rate){}
	  //重定义基类版本以实现有限折扣策略
	  //对低于上限的购书量使用折扣价格
	  double net_price(size_t  cnt)const
	  {
		  if (cnt<=quantity)
		  {
			  return cnt*(1-discount)*price;
		  } 
		  else
		  {
			  return cnt*price-quantity*discount*price;
		  }
	  }
};

#endif

//定义compare函数和Basket类头文件-------------------------"Basket.h"
#ifndef BASKET_H
#define BASKET_H
#include "Sales_item.h"
#include "D:\C++WORK\main.h"

//compare函数用于比较对象，以确定Basket的multiset成员中各元素的排序次序
inline bool  compare(const Sales_item &lhs,const Sales_item &rhs)
{
	return lhs->book()<rhs->book();
}

class Basket
{
private:
	typedef bool (*Comp)(const Sales_item &,const Sales_item &);
public:
	//multiset成员的类型
	typedef std::multiset<Sales_item,Comp>  set_type;
	//类型别名
	typedef set_type::size_type  size_type;
	typedef set_type::const_iterator  const_iter;

	Basket():items(compare){}//初始化比较器

	void add_item(const Sales_item &item)
	{
		items.insert(item);
	}

	size_type size(const Sales_item &i )const
	{
		return items.count(i);
	}

	double total()const ;//返回购物篮所有物品的总价格

private:
	std::multiset<Sales_item,Comp>  items;

};
#endif

//定义compare函数和Basket类的实现文件（源文件）----------------------Basket.cpp
#include "Basket.h"

double Basket::total()const
{
	double sum=0.0;//holds  the running total
	/*
	找到具有相同ISBN的每一组物品，根据其总数计算价格
	iter指向ISBN相同的每一组中的第一个元素
	upper_bound指向具有不同的ISBN的下一个元素
	*/
	for (const_iter iter = items.begin();iter!=items.end();iter=items.upper_bound(*iter))
	{
		//根据基础Item_base对象的类型调用相应的net_price函数
		sum+=(*iter)->net_price(items.count(*iter));
	}
	return sum;
}

#include "iostream"-------------------------main.h
#include "vector"
#include "string"
#include "list"
#include "deque"
#include "utility"
#include "map"
#include "set"
#include "fstream"
#include "sstream"
#include "algorithm"
#include "numeric"
#include "iterator"
#include "functional"

using namespace  std;

#include "Basket.h"---------------------------main15-35.cpp

int main(int argc,char * argv[])
{
	Basket basket;
	Sales_item  item1(Bulk_item("7-115-14554-7",99,20,0.2));
	Sales_item  item2(Item_base("7-115-14554-8",39));
	Sales_item  item3(Lds_item("7-115-14554-9",50,200,0.2));
	Sales_item  item4(Bulk_item("7-115-14554-7",99,20,0.2));

	basket.add_item(item1);
	basket.add_item(item2);
	basket.add_item(item3);
	basket.add_item(item4);

	cout<<basket.total()<<endl;

	return 0;
}

yangxuefeng09

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ Primer复习和学习笔记第十五章面向对象编程

#include "D:\C++WORK\main.h"//派生类和基类的默认参数的问题class Item_base{public: string _book; double _sales_price;public: Item_base(const string &book="Item_base",double sales_price= 1.0 ):_book(book),_sa
复制链接

扫一扫