cc26a_demo-CppPrimer_动态绑定_多态-代码示范

//多态性
    //从派生类到基类的转换
    //引用或者指针既可以指向基类对象，也可以指向派生类对象
    //只有通过引用或者指针调用虚函数才会发生动态绑定。
    //为什么定义虚的函数？可以重新定义。只有虚函数才可以重写，（基类或者派生类里面）

动态绑定的方法，执行出来的效果，就是多态

 

#include <iostream>//txwtech-202001
#include <string>//多态，动态绑定

using namespace std;//导入名称空间

class Animal
{
	//成员略
};

class Dog :public Animal
{
	//成员略
};
class Cat :public Animal
{

};
class Item_base
{
public:
	//int x;
	Item_base(const std::string &book = "",
		double sales_price = 0.0) :isbn(book), price(sales_price) {}//构造函数
	std::string book() const
	{
		return isbn;
	}
	virtual double net_price(size_t n) const//为什么定义虚的函数？可以重新定义。只有虚函数才可以重写
	{
		return n * price;
	}

private://类的内部使用
	std::string isbn;
protected://专门用来做继承用的
	double price;

};
class Bulk_item :public Item_base
{
public:
	Bulk_item(const std::string &book = "", double sales_price = 0.0,
		size_t qty = 0, double disc_rate = 0.0) :
		Item_base(book, sales_price), min_qty(qty), discount(disc_rate) {}
	void test()
	{
		//cout << x << endl;
		cout << price << endl;
		//cout << isbn << endl;
	}
	void test2(const Bulk_item &d, const Item_base &b)
	{
		//cout << d.x << endl;
		cout << d.price << endl;
		//cout << b.x << endl;
		//cout << b.price << endl;
	}
	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 &os, Item_base *item, size_t n)
{
	os << "ISBN: " << item->book() << "\t number sold: " << n << "\ttotal price: " << item->net_price(n) << endl;
	//item->net_price(n)代码就是多态的
}
int main()
{
	//Animal a;
	//Dog d;
	//Cat c;
	//Item_base item("0-12-3456-789", 9.9);
	//cout << item.book() << ": " << item.net_price(10) << endl;
	cout << item.x << endl;
	///*cout << item.isbn << endl;
	//cout << item.price << endl;*/
	cout << "hello111" << endl;
	//Bulk_item item2("0-12-3456-789", 9.9, 10, 0.12);
	cout << item2.x << endl;
	//cout << item2.book() << ": " << item2.net_price(10) << endl;
	//item2.test();
	//item2.test2(item2, item);

	//多态，动态绑定的实现

	Item_base* a = new Item_base("1-234-567-01",11.0);
	Bulk_item* b = new Bulk_item("1-234-567-02",22.0,2,0.05);//指向子类对象的指针

	print_total(cout,a,2);
	print_total(cout,b,3);

	Item_base* books[5];//指针数组，5个指针
	books[0] = new Item_base("0-123-456-01",10.0);//new 创建基类对象
	books[1] = new Bulk_item("0-123-456-01", 20.0,6,0.05);//new 也可以指向派生类对象
	books[2] = new Item_base("0-123-456-03", 30.0);//new 创建基类对象
	books[3] = new Bulk_item("0-123-456-04", 40.0, 4, 0.15);//new 也可以指向派生类对象
	books[4] = new Bulk_item("0-123-456-05", 50.0, 2, 0.18);//new 也可以指向派生类对象
	
	int num[5];
	num[0] = 2;
	num[1] = 10;
	num[2] = 1;
	num[3] = 5;
	num[4] = 3;

	for (int i = 0; i < 5; i++)
	{
		print_total(cout,books[i],num[i]);
		//动态绑定的方法，执行出来的效果，就是多态
	//根据指针所指向的对象不同，指向不同的对象，对象去调用不同的虚函数。有可能是基类，有可能是
	//派生类的。
	}
	//分别调用基类的netprice与派生类的Netprice. netprice就是多态，根据对象决定（基类不打折，派生类打折）
	//比如飞机在飞，鸟儿也在非，不同的飞
	
	
	getchar();
	return 0;

	//多态性
	//从派生类到基类的转换
	//引用或者指针既可以指向基类对象，也可以指向派生类对象
	//只有通过引用或者指针调用虚函数才会发生动态绑定。
	//为什么定义虚的函数？可以重新定义。只有虚函数才可以重写，（基类或者派生类里面）
}