c++之一键总结（三）

短命女 2022-03-16 05:56 129阅读 0赞

1，类中变量的继承和派生访问

class Base
    {
    private:	//本类内部可以访问
    protected:	//本类和派生的类可以直接访问
    	int a;
    	int b;
    public:
    	void show() {
    		cout << "Base " <<  a << " " << b << endl;
    	}
    };
    
    class Derived : public Base
    {
    public:
    	//如果定义了重名的变量，派生类里同时存在两个a
    	//基类的a被隐藏
    	int a;
    	int c;
    	void show() {
    		cout << "Derived ";
    		cout << Base::a << " " << 
    			" " << Derived::a << " " << 
    			b << " " << c << endl;
    	}
    };
    /*********************
      内存分布	:
    Base b;			Derived d;
    -------			---------
    int a			int a Base::a	<-	有同名的成员变量，		基类的a会被隐藏
    int b			int b
    				int a Derived::a <- 使用a就是派生的a
    				int c
    --------------------------------
     */

2，类的继承方式和访问权限

class Point
    {
    protected:
    	int x;
    	int y;
    public:
    	Point(int i, int j) : x(i), y(j) { 
    		cout << "Point 2 " << x << endl;
    	}
    	Point() : x(0), y(0) { 
    		cout << "Point 0 " << x << endl;
    	}
    	~Point() {
    		cout << "~Point " << x << endl;
    	}
    	int getX() const {
    		return x;
    	}
    	int getY() const {
    		return y;
    	}
    };
    
    ostream& operator<<(ostream& out, const Point& p)
    {
    	out << "(" << p.getX() << ", " << p.getY() << ")";
    	return out;
    }
    
    class Circle : protected Point
    {
    	//int x;
    	//int y;
    protected:
    	int r;
    	using Point::getY; //将该函数在派生类中保护起来
    public:
       //使用using改变基类在派生类中的权限
        using Point::getX;
    	using Point::x;   //将x变为public
    	//	using Point::x;	基类如果是私有，就是不能访问
    	
    	Circle() : r(0) { 
    		cout << "Circle 0 " << r << endl; 
    	}
    	Circle(int x, int y, int i) : Point(x, y), r(i) {
    		cout << "Circle 3 " << r << endl; 
    	}
    	~Circle() {
    		cout << "~Circle " << r << endl; 
    	}
    	int getR() const {
    		return r;
    	}
    	double area() const {
    		cout << getX() << endl;
    		return 3.14*r*r;
    	}
    	void allPoint() {
    		//圆心(x, y) 半径 r
    		int x1, y1;
    		for (int i=x-r; i<=x+r; i++) 
    			for (int j=y-r; j<=y+r; j++) {
    				//Point(i, j) - Point(x, y) 
    				x1 = i - x;
    				y1 = j - y;
    				if (x1*x1 + y1*y1 <= r*r)
    					cout << "(" << i << ", " << j << ")" << endl;
    			}
    	}
    };
    
    class Ball : Circle	//私有继承
    {
    	//int x;
    	//int y;
    	//int r;
    public:	
    	void show() {
    		cout << x << " " << y << " " << r << endl;
    	}
    };
    
    基类的权限			继承方式		派生的权限
    public				public			public
    protected							protected
    private								不可访问
    ----------------------------------------------
    public				protected		protected
    protected							protected
    private								不可访问
    ------------------------------------------------
    public				private			private
    protected							private
    private								不可访问

3,多态学习  
多态: 当派生类里有重写的函数的时候，***基类指针p指向任意派生的对象***（基类指针指向派生对象（基类指针是指向对象的指针）），p就访问哪个对象的函数

class Person
    {
    protected:
    public:
    	int id;
    	string name;
    	int age;
    	Person(int i, string n, int a) : id(i), name(n), age(a) {
    		cout << "Person 3 " << id << endl;
    	}
    	Person() {
    		cout << "Person 0 " << id << endl;
    	}
    	//虚函数
    	virtual void show() {
    		cout << "人 ";
    		cout << id << " " << name << " " << age << endl;
    	}
    	//使用基类指针释放派生对象，基类的析构函数一定要定义成虚析构函数
    	~Person() {
    		cout << "~Person" << endl;
    	}
    };
    
    class Student : public Person
    {
    public:
    	int score;
    /*	
    	Student() {//Preson() 
    		cout << "Student " << endl;
    	}
    	*/
    	void set(int i, string n, int a, int s) {
    		id = i;
    		name = n;
    		age = a;
    		score = s;
    	}
    	void show() {
    		cout << "学生 ";
    		cout << id << " " << name << " " << age << " ";
    		cout << score << endl;
    	}
    	~Student() {
    		cout << "~S " << id << endl;
    	}
    };
    class Teacher : public Person
    {
    	string subject;
    public:
    	//构造派生对象,默认调用基类的无参构造函数
    	Teacher() : Person(0, "", 0){ //Person() 
    		cout << "Teacher " << endl;
    	}
    	Teacher(int i, string n, int a, string s) 
    		: /*id(i),错误 Person部分还没初始化,还没有id*/
    		 Person(i, n, a), subject(s)
    	{
    		cout << "Teacher 4 " << id << endl;
    		// id = i;
    	}
    	void set(int i, string n, int a, string s) {
    		id = i;
    		name = n;
    		age = a;
    		subject = s;
    	}
    	//如果基类里有virtual void show()
    	//派生里的void show(), 被重写的show函数
    	void show() {
    		cout << "教师 ";
    		cout << id << " " << name << " " << age << " ";
    		cout << subject << endl;
    	}
    
    	~Teacher() {
    		cout << "~T " << id << endl;
    	}
    };
    /*
    Person p		Teacher t			
    ----------		--------
    id				id	
    name			name	Person 1	
    age				age		
    				=======	
    				score	Teacher 2
    */
    int main()
    {
    	Person* p = new Person(1001, "Tom", 32);
     //静态绑定，在程序还没运行的时候就知道绑定了什么函数
    	//动态绑定，在程序运行之后才能知道具体调用的函数
    	Teacher* t = new Teacher(2001, "Mike", 30, "math");
    	p->show();
    	delete p;
    //	Person& r = t;	/**多态只能通过指针和引用实现**\  *这就是多态吗？*
    //	r.show();
    	p = t;//小的指针指向大的空间是合法的 （派生指向基类）
    			//基类指针可以指向派生对象
    			//派生指针不能指向基类对象	
    //	t = p;	大的指针指向小的空间,会访问到不合法的位置
    	p->show();
    	delete p;
    //	p = new Student;
    
    //	p.show();
    	//基类指针不能访问派生的成员变量
    	//cout << p->score << endl;
    #if 0
    Person* arr[8];
    	int id;
    	string name;
    	int score;
    	int count;
    	for (int i=0; i<4; i++) {
    		cin >> id >> name >> score;
    		//arr[i]是指向Person基类指针，Student是person的派生对象。
    		arr[i] = new Student(id, name, score);//派生对象指向基类指针
    	}
    	for (int i=4; i<8; i++) {
    		cin >> id >> name >> count;
    		arr[i] = new Teacher(id, name, count); //派生对象指向基类指针
    	}
    	cout << "优秀的学生和教师名单:" << endl;
    	for (auto m : arr) {
    		if (m->isGood())
    			m->show();
    		delete m;
    	}
    #endif
    	return 0;
    }

**注意：**  
（1）Person p;//错误， 抽象的类不能定义实例  
（2）Person\* p = new Person; //错误  
（3）只能用Person*定义;申请空间在派生类中申请。  
例：Person* arr\[8\]; //定义  
arr\[i\] = new Student(id, name, score); //申请空间  
arr\[j\] = new Teacher(id, name, count);

/*
    写一个基类Shape(形状) ，是一个抽象类
    class Shape {
    	double area;	//表面积
    	double volume;	//体积
    	virtual double getArea() = 0;
    				   getVolume() = 0;
    };
    正方体
    class Cube : public Shape
    {
    };
    球体
    class Ball : public Shape
    {
    };
    圆柱体
    class Cylinder : public Shape
    {
    };
    做一个选项，选择想要作出的图形
    1, 正方体
    2, 球体
    3, 圆柱体
    */
    #include <iostream>
    using namespace std;
    #define PI 3.14159
    class Shape
    {
    protected:
    	double area;
    	double volume;
    public:
    	Shape() : area(0), volume(0) { }
    	virtual ~Shape() { }
    	virtual double getArea() = 0;
    	virtual double getVolume() = 0;
    };
    class Cube : public Shape
    {
    	double l;
    public:
    	Cube(double i=0) : l(i) { }
    	double getArea() override { 
    		return 6*l*l;
    	}
    	double getVolume() override { 
    		return l*l*l;
    	}
    };
    class Ball : public Shape
    {
    	double r;
    public:
    	Ball(double i=0) : r(i) { }
    	double getArea() {
    		return 4*PI*r*r;
    	}
    	double getVolume() {
    		return 4.0/3*PI*r*r*r;
    	}
    };
    class Cylinder : public Shape
    {
    	double h;
    	double r;
    public:
    	Cylinder(double i, double j) : h(i), r(j) { }
    	double getArea() {
    		return 2*PI*r*(r + h);
    	}
    	double getVolume() {
    		return PI*r*r*h;
    	}
    };
    
    int main()
    {
    	Shape* p = nullptr; //定义基类对象
    	string s;
    	double i, j;
    	while(1) {
    		system("clear");
    		cout << "请选择想要构造的形状: " << endl;
    		cout << "1, 正方体 " << endl;
    		cout << "2, 球体   " << endl;
    		cout << "3, 圆柱体 " << endl;
    		cout << "其他, 退出" << endl;
    		cin >> s;
    		if (s == "1") {
    			cout << "请输入边长: ";
    			cin >> s;
    			i = atof(s.c_str());
    			p = new Cube(i);
    		} else if (s == "2") {
    			cout << "请输入半径: ";
    			cin >> s;
    			i = atof(s.c_str());
    			p = new Ball(i);
    		} else if (s == "3") {
    			cout << "请输入圆柱的半径: ";
    			cin >> s;
    			i = atof(s.c_str());
    			cout << "请输入圆柱的高: ";
    			cin >> s;
    			j = atof(s.c_str());
    			p = new Cylinder(j, i); //多态的应用，派生对象指向基类对象（指针）
    		} else 
    			break;
    		cout << "体积为: " << p->getVolume() << 
    			" 表面积为: " << p->getArea() << endl << endl;
    		cout << "按回车键继续" << endl;
    		delete p;
    		
    		getchar();
    		getchar();
    	}
    	return 0;
    }

4，虚函数学习

/有纯虚函数的类叫做抽象类, 抽象类不能定义对象
    class Person
    {
    protected:
    	int id;
    	string name;
    public:
    	Person() : id(0) { }
    	Person(int i, string n) : id(i), name(n) { }
    	//纯虚函数，没有函数体 
    	virtual void show() { }
    	virtual bool isGood() { }
    	void fun() { }
    	virtual ~Person() { 
    		cout << "~P " << endl;
    	}
    };
    Person p;
    Teacher t;
    //Person& r = t;
    Person* p = new Person;
    ---------
    (pvtab)虚函数表的指针 -->[P::show|P::isGood|~Person]
    id
    name
    //如果派生类没有对基类的虚函数重写，派生类的虚函数表存储的是基类虚函数的地址
    //如果派生类里对基类的虚函数进行重写，派生类的虚函数表就会被改变
    Person* p = new Teacher;
    --------
    (pvtab)				-->[T::show|P::isGood|~Teacher] 
    id
    name
    ======
    count
    //当基类是抽象类，派生类如果要定义对象必须对基类的虚函数进行重写

5，多继承

class Person
    {
    protected:
    	string name;
    	int age;
    public:
    	Person(string n="", int a=0) : name(n), age(a) { }
    	virtual void show() {
    		cout << "人 " << name << " " << age << "岁" << endl;
    	}
    };
    class Teacher
    {
    protected:
    	string school;
    	string subject;
    public:
    	Teacher(string sc="", string su="") : school(sc), subject(su) { 
    	}
    	void show() {
    		cout << "教师 学校:" << school << " 学科:" << subject << endl;
    	}
    };
    class Proffessor : public Person, public Teacher
    {
    	string titel;
    public:
    	Proffessor() = default; //使编译器合成默认的构造函数
    //	Proffessor() = delete; //阻止编译器合成拷贝构造函数
    	//多继承
    	Proffessor(string n, int a, string sc, string su, string t) : Person(n, a), Teacher(sc, su), titel(t) { }
    	void show() {
    		cout << "教授 名字:" << name << " 年龄:" <<
    			age << " 学校:" << school << " 学科:" <<
    			subject << " 职称:" << titel << endl;
    	}
    };
    int main()
    {	
    	Proffessor p("Tom", 30, "清华", "数学", "讲师");
    	p.show();
    	Person p1("Mike", 23);
    	Teacher p2("一中", "英语");
    	Person* q = &p1;
    	q->show();
    	q = &p; //多态
    	q->show();
    	return 0;
    }

虚继承  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4MzI1_size_16_color_FFFFFF_t_70]

class A
    {
    protected:
    	int a;
    public:
    	A() { cout << "A" << endl; }
    	A(int i) : a(i) { cout << "A " << a << endl; }
    	virtual void show() {
    		cout << "show A " << a << endl;
    	}
    };
    
    class B1 : virtual public A
    {
    protected:
    	int b1;
    public:
    	B1() { cout << "B1" << endl; }
    	B1(int i) : A(10), b1(i) { 
    		cout << "B1 " << b1 << " " 
    		<< a<< endl; 
    	}
    	void show() override {
    		cout << "show B1 " << a << " " << b1 << endl;
    	}
    };
    class B2 : virtual public A
    {
    protected:
    	int b2;
    public:
    	B2() { cout << "B2" << endl; }
    	B2(int i) : A(20), b2(i) { cout << "B2 " << a 
    		<< " " << b2 << endl; }
    	void show() override {
    		cout << "show B2 " << a << " " << b2 << endl;
    	}
    };
    
    class D : public B1, public B2
    {
    	int d;
    public:
    	// : B1(), B2() 
    	//　必须先构造共同基类
    	D() : A(), B1(), B2() { cout << "D" << endl;}
    	D(int i1, int i2, int i3, int i4) : 
    		A(i1), B1(i2), B2(i3), d(i4)
    	{
    		cout << "D " << a << " " << b1 << " "
    			<< b2 << " " << d << endl;
    	}
    	void show() {
    	//	cout << B1::a << " " << B2::a << " " << 
    		cout << "show ";
    		cout << a << " " << 	
    		b1 << " " << 
    			b2 << " " << d 
    			<< endl;
    	}
    };

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDA4MzI1_size_16_color_FFFFFF_t_70]: /images/20220316/2175cc6af14b47f59178f26e8543b3f9.png