C++——继承，多态

继承：

知识点1：

应用1：
子类继承过来的成员函数，以及保护成员变量，子类可以直接使用！
子类对象调用父类成员函数，改变的是自己空间的成员变量值？？？

#include<iostream>
using namespace std;
class A
{
public:
    void get_XY() { cout << "请输入两个点" << endl;cin >> x >> y; }
    void put_XY() { cout << "x=" << x << ",y=" << y << endl; }
protected:
    int x, y; //子类可以直接使用保护类型的变量
};

class B :public A
{
public:
    void set_S() { s = x * y; }
    int  get_S() { return s; }
protected:
    int s;

};
class C:public B
{
public:
    void get_H()
    {
        cout << "请输入h" << endl;
        cin >> h;
    }
    int get_V() { return v; }
    void set_V() { v = h * get_S(); } // 正解：{set_s();v=h*get_s();}
    //直接使用基类的成员函数，用基类的函数操纵的是自己空间的成员
protected:
    int h, v;
};
int main()
{
    A a;
    B b;
    C c;
    cout << " 这是对象a:" << endl;
    a.get_XY();
    a.put_XY();
    cout << " 这是对象b:" << endl;
    b.get_XY();
    b.set_S();
    cout << "s=" << b.get_S() << endl;
    cout << " 这是对象c:" << endl;
    c.put_XY(); 
    //调用的是自己空间的变量值，而此时自己空间的值并没有设置，所以运行结果如下图
    c.get_XY();
    c.set_V();
    cout << "v=" << c.get_V() << endl;
}

应用2：如何使用被子类重写的基类的成员函数

#include<iostream>
#include<stringusing namespace std;

class Person {
private:
	string name;
	int age;
	string sex;
public:
	void set() {
		cout << "输入人的信息：" << endl;
		cin >> name >> age >> sex;
	}
	void show()
	{
		cout << name << " " << age << " " << sex << endl;
	}
};
class Student :public Person
{
	string sno;
	string major;
	string s_class;
	float score;
public:
	void set()
	{
		Person::set();//使用已经被屏蔽掉的基类的成员函数
		cout << "请输入学生的信息" << endl;
		cin >> sno >> major >> s_class >> score;
	}
	void show()
	{
		Person::show();
		cout << major << " " << s_class << " " << score << endl;
	}
};

int main()
{
	Person* p;
	Student st;
	st.set();
	st.show();
	cout << "将派生类地址赋给基类指针："<<endl;
	p = &st;
	p->set();//调用的是基类的成员函数
	p->show();//证明改变的是派生类自己空间的值？？？
}

运行结果：
输入人的信息：
小李 21 女
请输入学生的信息
2018215269 计算机 五班 98
小李 21 女
计算机 五班 98
将派生类地址赋给基类指针：
输入人的信息：
小王 21 男
小王 21 男

知识点二：

应用：利用派生类构造函数初始化基类成员和派生类对象成员

#include<iostream>
#include<string>
using namespace std;

class Fu
{
	int data1, data2;
public:
	Fu(int f1, int f2) { data1 = f1;data2 = f2; }
	int inc1() { return ++data1; }
	int inc2() { return ++data2; }
	void display() { cout << "data1=" << data1 << " " << "data2=" << data2 << endl; }

};

class Zi :public Fu
{
	int data3;
	Fu data4;
public:
	Zi(int z1, int z2, int z3, int z4, int z5) :Fu(z1, z2), data4(z3, z4)
	{
		data3 = z5;
	}
	int inc1()
	{
		cout << "父类的inc1被覆盖，调用子类的inc1" << endl;
		return Fu::inc1();
	}
	int inc3() { return ++data3; }
	void show()
	{
		display();  //不加前面限定符 默认调用的是父类空间的数据
		cout << "........................" << endl;;
		Fu::display();
		cout << "..................." << endl;
		data4.display();
		cout << "data3=" << data3 << endl;

	}

};

int main()
{
	Fu* ff;
	Zi zz(5, 9, 3, 78, 12);
	zz.inc1();
	zz.show();
	ff = &zz;
	cout << "  -------------" << endl;
	cout << ff->inc1();
}
运行结果：
父类的inc1被覆盖，调用子类的inc1
data1=6 data2=9
........................
data1=6 data2=9
...................
data1=3 data2=78
data3=12
  -------------
6

知识点3：

知识点4：

应用1：

Base b;
Derived d;
b=d;

Derived d;
Base &br=d;

Derived d;
Base *ptr=&d;

应用二：

class Person{     };
class Student:Public Person{     };
void eat(Person &p){};
void study(Student &s){};
void main()
{ Person p;
Student s;
eat(p);
eat(s);
study(s);
study(p);//错误！

虚函数与多态：

应用1：
1.基类指针引用派生类对象
2.如何用基类指针访问派生类新增的成员

#include<iostream>
#include<cstring>

using namespace std;

class Base
{
public:
	Base(char xx) { x = xx; }
	void who() { cout << "Base class:" << x << endl; }
protected:
	char x;
};

class First_d :public Base
{
public:
	First_d(char xx, char yy) :Base(xx) { y = yy; }
	void who() { cout << "First_d:" << x << "," << y << endl; }
protected:
	char y;
};

class Second_d :public First_d
{
public:

	Second_d(char xx, char yy, char zz) :First_d(xx, yy) { z = zz; }
	void who() { cout << "Second_d:" << x << "," << y << "," << z << endl; }
protected:
	char z;
};

int main()
{
	Base b('A');
	First_d fd('T', 'O');
	Second_d sd('E', 'P', 'M');
	Base* pr;
	pr = &b;
	pr->who();
	pr = &fd;
	pr->who();
	pr = &sd;
	pr->who();
	fd.who();
	((First_d*)pr)->who();
	((Second_d*)pr)->who();

	return 0;

运行结果：
Base class:A
Base class:T
Base class:E
First_d:T,O
First_d:E,P
Second_d:E,P,M

}

应用2：虚函数的使用，用来访问重写的派生类成员函数

#include<iostream>
using namespace std;
class Base
{
public:
	virtual void vf1();
	virtual void vf2();
	virtual void vf3();
	void f();

};
class derived :public Base
{
	int x;
public:
	void vf1();//虚函数
	void vf2(int x);//重载，虚特性丢失
    //char vf3();//error
	void f();
};
int main() {
	derived d;
	Base* b = &d;
	b->vf1();//访问derived::vf1();
	b->vf2();//访问Base::vf2();
	b->f();//调用Base::f();
}

应用3：成员函数调用虚函数（采用动态联编）

#include<iostream>
using namespace std;
class A {
public:
	virtual double funA(double x)
	{
		cout << "A 类的funA（）被调用" << endl;
		return x * x;
	}
	double funB(double x)
	{
		return funA(x) / 2;
	}
};
class B :public A
{
public:
	double funA(double x)
	{
		cout << "B 类的funA（）被调用" << endl;
		return 2 * x * x;
	}
};
class C :public B
{
public:
	 double funA(double x)
	{
		cout << "C 类的funA（）被调用" << endl;
		return 3 * x * x;
	}
};
int main()
{
	C objc;
	cout << objc.funB(3) << endl;
	B objb;
	cout << objb.funB(3) << endl;
}
结果：
C 类的funA（）被调用
13.5
B 类的funA（）被调用
9

应用四：
纯虚函数和抽象类的使用：

#include<iostream>
using namespace std;

class Number
{
public:
	Number(int i) { val = i; }
	virtual void show() = 0;
protected:
	int val;
};

class Hex_type:public Number
{
public:
	Hex_type(int i):Number(i){ }
	void show() { cout << "16进制:" << hex << val << endl; }
};
class Dec_type :public Number
{
public:
	Dec_type(int i):Number(i){ }
	void show() { cout << "10进制：" << dec << val << endl; }
};

class Oct_type :public Number
{
public:
	Oct_type(int i):Number(i){ }
	void show() { cout << "8进制：" << oct << val << endl; }
};
void fun(Number& n)
{
	n.show();
}
int main()
{
	Dec_type n1(50);
	fun(n1);//相当于 Dec_type::show();
	Hex_type n2(10);
	fun(n2);//相当于 Hex_type::show();Number *n=&n2;
结果：
10进制：50
16进制:a
}

学习感悟