C++:多态(面向对象的主要手段之一)

//两种动态-静态动态(编译时动态)/动态动态（运行时动态)
//1 静态动态(编译时动态)-函数重载，函数模板【通过函数匹配等条件在编译时匹配函数】
//int main()
//{
//	int i = 1;
//	double d = 2.1;
//	cout << i << d << endl;//静态动态，这里对于输出两个不同类型的变量，看起来是调用同一个函数，
//	//实际上是通过函数重载分别调用两个不同的函数
//}

//2动态动态（运行时动态)
//必须满足条件：2.1必须是基类的指针或者引⽤调⽤虚函数
//2.2被调⽤的函数必须是虚函数，并且完成了虚函数重写/覆盖。
class Person {
public:
	virtual void BuyTicket()//虚函数
	{
		cout << "买票-全价" << endl;
	}
};

class Student :public Person {
public:
	virtual void BuyTicket()
	{
		cout << "买票-打折" << endl;//虚函数的重写
	}
};

void func(Person& ptr)//使用基类的引⽤调⽤虚函数
{
	ptr.BuyTicket();//调⽤的函数是虚函数
}

void func(Person* ptr)//使用基类的指针调⽤虚函数
{
	ptr->BuyTicket();//调⽤的函数是虚函数
}

int main()
{
	Person ps;
	Student st;
	func(&ps);
	func(&st);
	return 0;
}

class Person
 {
 public:
 virtual void BuyTicket() { cout << "买票-全价" << endl;}//虚函数
 };

class Animal
{
public:
	virtual void talk() const//发出叫声的函数
	{
	}
};

class Dog :public Animal
{
public:
	virtual void talk() const//跟基类完全相同的虚函数
	//(即派⽣类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同，三同)
	{
		cout << "汪汪"<<endl;
	}
};

class Cat :public Animal 
{
public:
	virtual void talk() const////跟基类完全相同的虚函数
	//(即派⽣类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同，三同)
	{
		cout << "(>^ω^<)喵"<< endl;
	}
};

void letsHear(const Animal& animal)
{
	animal.talk();
}

int main()
{
	Dog dog;
	Cat cat;
	letsHear(dog);
	letsHear(cat);
	return 0;
}

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};
class B : public A
{
public:
	 void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();//对于多态的调用，重写只是实现(定义)，而函数的声明还是基类中对应函数的声明，
	//所以一个重写的函数是基类中的声明+派生类中的定义，只有多态的调用是这样。

	//// 不是多态调用
	p->func();
	return 0;
}

//协变   
//1与自己基类和自己的派生类作的指针或引用为返回值
class Person {
public:
	virtual Person* BuyTicket()
	{
		cout << "买票-全价" << endl;
		return nullptr;
	}
};
class Student : public Person {
public:
	virtual Student* BuyTicket()
	{
		cout << "买票-打折" << endl;
		return nullptr;
	}
};
void Func(Person* ptr)
{
	ptr->BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(&ps);
	Func(&st);
	return 0;
}

//2作为一对满足基类和派生类关系的指针或引用返回值

class A {};
class B : public A {};
class Person {
public:
	virtual A* BuyTicket()
	{
		cout << "买票-全价" << endl;
		return nullptr;
	}
};
class Student : public Person {
public:
	virtual B* BuyTicket()
	{
		cout << "买票-打折" << endl;
		return nullptr;
	}
};
void Func(Person* ptr)
{
	ptr->BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(&ps);
	Func(&st);

	return 0;
}

class A
{
public:
	 virtual~A()//基类的析构函数一定要加virtual关键字(虚函数)
	{
		cout << "~A()" << endl;
	}
};
class B : public A {
public:
	~B()//派生类可加可不加virtual关键字(因为继承)
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};
int main()
{
	A* p1 = new A;
	A* p2 = new B;
	delete p1;
	delete p2;

	return 0;
}

// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法
class Car {
public:
virtual void Dirve()
{}
};
class Benz :public Car {
public:
virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{
return 0;
}


// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{
return 0;
}

class Car
{
public:
virtual void Drive() = 0;//纯虚函数
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};

class BMW :public Car
{
public:
virtual void Drive()
{
cout << "BMW-操控" << endl;
}
};
int main()
{
// 编译报错：error C2259: “Car”: ⽆法实例化抽象类
Car car;//car包含纯虚函数所以是抽象类
Car* pBenz = new Benz;//抽象类可以定义指针/引用
pBenz->Drive();
Car* pBMW = new BMW;
pBMW->Drive();
return 0;
}

class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
protected:
int _b = 1;
char _ch = 'x';
};
int main()
{
Base b;
cout << sizeof(b) << endl;
return 0;
}

class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:
string _name;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:
string _id;
};
class Soldier: public Person {
public:
virtual void BuyTicket() { cout << "买票-优先" << endl; }
private:
string _codename;
};
void Func(Person* ptr)
{
// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
ptr->BuyTicket();
}
int main()
{
// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后
// 多态也会发⽣在多个派⽣类之间。
Person ps;
Student st;
Soldier sr;
Func(&ps);
Func(&st);
Func(&sr);
return 0;
}

class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:
string _name;
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:
string _id;
};
class Soldier: public Person {
public:
virtual void BuyTicket() { cout << "买票-优先" << endl; }
private:
string _codename;
};
void Func(Person* ptr)
{
ptr->BuyTicket();
}

int main()
{
// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后
// 多态也会发⽣在多个派⽣类之间。
Person ps;
Student st;

Func(&ps);
Func(&st);

return 0;
}

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
	virtual void func1() {}
	void func2() {}
private:
	string _name;
};

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-打折" << endl; }

	virtual void func3() {}

private:
	string _id;
};

class Soldier : public Person {
public:
	virtual void BuyTicket() { cout << "买票-优先" << endl; }
private:
	string _codename;
};

void Func(Person* ptr)
{
	// 这里可以看到虽然都是Person指针Ptr在调用BuyTicket
	// 但是跟ptr没关系，而是由ptr指向的对象决定的。
	ptr->BuyTicket();
}

int main()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);

	Student st;
	Student* ptr = &st;
	printf("虚函数表地址:%p\n", *((int*)ptr));

	return 0;
}