封装：提高代码维护性；（遇到问题能够准确定位）
继承：提高代码复用性；（不是ctrl+c ctrl+v,不是任何修改或者操作源代码就能实现代码的复用）
多态：提高代码扩展性

#include <iostream>

using namespace std;
class A
{
public:
    void print()
    {
        cout << "hello world" << endl;
    }
    int m_num = 12;
protected:
    int m_index = 13;
private:
    int m_count = 15;

};

A是B的父类；B是A的子类
A是B的基类；B是A的派生类,派生类的实例化对象大小：父类的对象大小 + 派生类的新成员；
覆盖:派生类拥有与基类相同的属性或者方法时，派生类会覆盖；
/**

• 继承方式:
• public公有继承：基类的公有成员和属性成为派生类的公有；基类的被保护的属性和方法成为派生类的被保护；基类私有成员不能被继承；
• !private:私有继承:基类的公有成员和属性成为派生类的私有；基类的被保护的属性和方法成为派生类的私有；基类私有成员不能被继承；
• !protected被保护继承:基类的公有成员和属性成为派生类的被保护的；基类的被保护的属性和方法成为派生类的被保护的；基类私有成员不能被继承；
  */

class B :protected A    //private protected public
{
public:
    //A a;//组合:
    //int m_num;
    //int count;
    void func()
    {
       // a.func();
        //cout << m_index <<endl;被保护可访问
        //cout << m_count << endl;私有不可访问
        print();
    }
    //void print()
   // {
      //  cout << "hi world" << endl;
    //}


};

多态：一种代码写法，多种表现形式
函数重写/名字隐蔽

#include <iostream>

using namespace std;

class A
{
public:
A(int a)
{

m_a = a;

}
virtual void print()
{
cout <<"这是父类的print函数"<<endl;
}
class B
{
public:
B(int a,int b):A(a),m_b(b)
{


}

}

多态的形成条件：

1. 要有继承关系；
2. 用虚函数进行函数重写；
3. 用父类的指针指向子类的对象。

静态联编和动态

#include <iostream>
using namespace std;
class A
{
public:
  virtual void print()
  {
   cout <<"AAAAAA" <<endl;
  }
};
class B:public A
{
public:
  void print ()
  {
   cout <<"BBBBBB" <<endl;
  }
};
int main()
{
A *pa = new A;
pa->print();

pa = new B;
pa->print();//在编译是确定，静态联编；
return 0;
}

虚析构函数：通过父类指针释放子类对象；

析构函数为什么一定要声明虚函数？
因为当基类的指针指向子类的对象，基类指针释放时

#include <iostream>
using namespace std;

class A
{
public:
 A(int 1);
 virtual ~A();
 protected:
 int m_len;
};
A::A(int 1)
{
 cout <<"A的构造函数被释放" <<endl;
 m_len = 1；
}
A::~A（）
{
cout <<"A的析构函数被释放" <<endl;
  delete m_len ;
}
class Array:public A
{
public:
Array(int 1);
~Array();
private:
char *m_data;
};
Array::Array(int 1):A(1)
{
cout<<"Array 构造函数被调用！"<<endl;
m_data = new char[m_len+1];
}
Array::~Array()
{
cout<<"Array 的析构函数被调用！"<<endl;
delete m_data;//造成子类的指针没有办法被释放
}

int main()
{
A *pa = new Array(10);
delete pa;

return 0;
}

多态原理

#include <iostream>
using namespace std;

class A
{
public:
A();
virtual void show();
//添加一个虚函数表指针
public:
int m_a;
};

A::A()
{
m_a = 1;
show();
}
void A::show()
{
 cout <<"AAAAAA" <<endl;
}
class B:public A
{
public:
void show();
public:
int m_b;
};
void B::show()
{
 cout <<"BBBBBB" <<endl;
 }
int main()
{
A a;
cout<<&a<<endl;
cout<<&a.m_a<<endl;
//cout<<&a.m_b<<endl;
return 0;
}