C++的继承，封装，多态

C++是面向对象的语言，因此他和JAVA一样有面向对象语言的三大基本特征：封装，继承，多态。
封装：封装字面意思就是打包，包装起来，看不见里面是啥。稍微专业点就是指按照信息屏蔽的原则，把对象的属性和操作结合在一起，构成一个独立的对象，通过限制属性和操作的访问权限（public, protected,private）,可以将属性“隐藏”在对象的内部，那都隐藏了外面就不好操作了，放心，这里会提供一定的接口，在对象之外只能通过这个接口对对象进行操作。就像开车给你钥匙，你会开车就能把车开走，具体车里面的发动机啥的不需要你知道，也不用知道。封装增强了对象的独立性，从而保证了对象的独立性。如下代码

#include <iostream>
#include <cstring>

using namespace std;

class People
{
    private:             //私有的属性不允许类的外部访问   封装
        char m_name[32];
        int m_age;
        int m_id;

    public:
        People()  //构造函数
        {

        }

        void SetValue(char *name, int age, int id)    //通过这个函数来改变私有变量的成员值
        {
            strcpy(m_name,name);
            m_age = age;
            m_id = id;
        }

        void print()   //打印
        {
            cout<<"m_name = "<<m_name<<" m_age = "<<m_age<<" m_id = "<<m_id<<endl;
        }
    
};


int main(int argc, char const *argv[])
{
    People p;
    p.SetValue("zhangsan",20,1010);  //输入值
    p.print();

    return 0;
}

继承：继承表达了对象的一般与特殊的关系，特殊类的对象具有一般类的全部属性和服务。我定义一个类之后，还需定义一个类，但是这个类和第一个定义的类中属性和方法只是增加了一些属性和操作，这时我们就可以用原来的类派生一个新类，只需在新类中描述自己所特有的属性和操作即可。所以说继承大大简化了对问题的描述，提高了程序的可重用性，也提高了程序设计，修改，扩充的效率。

#include <iostream>
#include <cstring>

using namespace std;

class Person    //父类或者基类
{
    protected:
        char m_name[32];
        int m_age;
    
    public:
        Person()
        {
            strcpy(m_name,"小苗");
            m_age = 18;
        }
};

class Student:public Person     //子类或者派生类，public继承权限
{
    private:
        int id;
    
    public:
        Student(int id)
        {
            this->id;
        }

        void show()
        {
            cout<<"m_name = "<<m_name<<" m_age = "<<m_age<<" id = "<<id<<endl;
        }
};

int main(int argc, char *argv[])
{
    Student s1(100);
    s1.show();
    
    return 0;
}

多态：多态性是指同一个消息被不同对象接收时，产生不同的结果，即实现同一接口，不同方法。在一般类中定义的属性和操作，如果在特殊类中不改变其名字， 通过各自不同的实现后，可以具有不同的数据类型或具有不同的行为。
实现多态的三个先决条件：
进行了类的继承；
子类与父类写了结构相同的函数(并且基类的函数是虚的)；
使用了基类指针指向了子类的对象

语法：

#include <iostream>
#include <cstring>

using namespace std;
//条件1，2
calss A{
	public:
		virtual void print(){}   //虚函数
};
class B:public A{
	public:
		void print(){}
};
//条件3
int main(){
	A *p;
	B q;
	p=&q;（基类的指针指向子类的对象）//此时便可以进行多态实现
	return 0;
}

实例：基类自己和他的派生类去打架，实现多种状态，打输了，打赢了。

//实现多态的案例;
#include<iostream>
using namespace std;
class OUr {
public:
	int a=15;
	virtual int get() {//进行虚函数处理;仅仅将这一个函数进行了虚函数处理;
		return a;//其他没有进行虚处理的函数还会有老的问题
	}
	void print() {
		cout << "我是父亲" << endl;
	}
};
class him :public OUr{
public:
	int h=25;
	int get() {
		return h;
	}
	void print() {
		cout << "我是 Tom" << endl;
	}
};
class me :public OUr {
public:
	int m=30;
	int get() {
		return m;
	}
	void print() {
		cout << "我是 zsc" << endl;
	}
};
class Diren {
public:
	int D = 26;
	int get() {
		return D;
	}
	void print() {
		cout << "我是Diren" << endl;
	}
};
void zhanzheng(OUr* p, Diren& a) {
	if (p->get() > a.get()) {
		cout << "我们将敌人秒杀了" << endl;
	}
	else {
		cout << "我们败北" << endl;
	}
}
int main_02() {
	OUr * p;
	him friends;
	me zsc;
	Diren DDD;
	p = &friends;
	zhanzheng(p,DDD);
	p = &zsc;
	zhanzheng(p, DDD);
	p->print();//打印基类的print函数；
	return 0;
}