C++-继承-多态

三种继承：

        公有继承 public：也称为接口继承，最常用，可以在子类的内部使用父类的public和protected成员

        私有继承 private：把所有的父类成员变成子类的私有成员

                通过 using 父类::成员，可以将转换后的私有成员变为公有的

        受保护的继承 protected：把父类的public变成子类的protected，private不变

对于友元关系，必须明确授予，不能继承。

继承

#include <iostream>

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:
	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;
	}
	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;//受保护类型只能在类的内部使用
	}

	//重新定义虚函数net_price
	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;
};
int main()
{
	Item_base item("0-102-2456-124124",9.9);
	cout << item.book()<<","<<item.net_price(8) << endl;
	Bulk_item item2("0-102-2456-124124",9.9,10,0.12);
	//cout << item2.x;
	cout << item2.book() << "," << item2.net_price(8) << endl;
	item2.test();
	item2.test2(item2,item);
	return 0;
}

动态绑定

动态绑定的效果就是多态，必须传出对象的指针或引用，不能只传入对象：

#include <iostream>

using namespace std;


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:
	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){}
	
	//重新定义虚函数net_price,超过一定数量打折
	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() << "\tnumber sold: " << n << "\ttotal price" << item->net_price(n) << endl;	//不同的对象调用不同的net_price()
}
int main()
{
	Item_base* a = new Item_base("1-234-567-01",11.00);
	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];
	books[0] = new Item_base("0-123-456-01",10.0);
	books[1] = new Bulk_item("O-123-456-02", 20.0, 6, 0.05);
	books[2] = new Item_base("O-123-456-03",30.0);
	books[3] = new Bulk_item("0-123-456-04", 40.0,4,0.15); 
	books[4] = new Bulk_item("0-123-456-05",50.0,2,0.18);

	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]);
	}
	return 0;
}

转换与继承： 

#include <iostream>

using namespace std;

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:
	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;
	}
	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;//受保护类型只能在类的内部使用
	}

	//重新定义虚函数net_price
	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_1(ostream &os,const Item_base item, size_t n)
{
	os << "ISBN: " << item.book() << "\tnumber sold: " << n << "\ttotal price " << item.net_price(n) << endl;
}
void print_total_2(ostream& os, const Item_base *item, size_t n)
{
	os << "ISBN: " << item->book() << "\tnumber sold: " << n << "\ttotal price " << item->net_price(n) << endl;
}
void print_total_3(ostream& os, const Item_base& item, size_t n)
{
	os << "ISBN: " << item.book() << "\tnumber sold: " << n << "\ttotal price " << item.net_price(n) << endl;
}
int main()
{
	Item_base item("0-102-2456-124124", 9.9);
	
	Bulk_item item2("0-102-2456-124124", 9.9, 10, 0.12);
	//cout << item2.x;
	
	print_total_1(cout,item,10);
	print_total_1(cout, item2, 10);	//对象转换有问题

	//动态绑定多态，必须采用以下两种方法
	print_total_2(cout,&item,10);
	print_total_2(cout,&item2,10);	//指针转换，没有问题
	print_total_3(cout, item, 10);
	print_total_3(cout, item2, 10);	//引用转换，没有问题

	//强制转换父类到子类，必须用指针和引用，不过不需要 
	Bulk_item* p = static_cast<Bulk_item*>(&item);
	cout << p->net_price(10) << endl;

	return 0;
}

静态成员与继承

#include <iostream>

using namespace std;

class A
{
public:
	//静态函数
	static std::size_t object_count()
	{
		return 100;
	}
protected:
	static const std::size_t obj_count = 99;
};

class B : public A
{
public:
	void f(const B& b, B* b2)
	{
		cout << A::obj_count << endl;
		cout << B::obj_count << endl;
		cout << b.obj_count << endl;
		cout << b2->obj_count << endl;

		cout << A::object_count() << endl;
		cout << B::object_count() << endl;
		cout << b.object_count() << endl;
		cout << b2->object_count() << endl;
		cout << object_count() << endl;
	}
};
int main()
{
	B b;
	b.f(b, &b);

	return 0;
}