1.面向对象指的是继承，封装，多态。
继承主要关注类的构造，赋值，析构。
以下对多态，封装进行补充说明。
2、多态
2.1.定义
a.赋值
派生类的指针，可以赋值给基类的指针。
派送类的对象，可以赋值给基类的引用。
b.调用
通过基类指针调用基类虚函数时，若派生类提供了派生实现，则调用派生类版本。
通过基类引用调用基类虚函数时，若派送类提供了派送实现，则调用派生类版本。
2.2.最佳实践
基类的析构函数应该定义成虚函数。
#include <iostream>class Base
{
public:Base() {}virtual void fun(){printf("B_fun()\n");}virtual ~Base(){printf("~Base()\n");}protected:int m_pro;private:int m_pri;
};class A : public Base
{
public:A() : Base() {}void fun(){printf("A_fun()\n");}~A(){printf("~A()\n");}
};int main()
{A *pA = new A();Base *pB = pA;pB->fun();delete pB;A a;Base &b = a;b.fun();return 0;
}
2.3.注意点
多态针对类外部使用基类指针或基类引用调用基类虚函数时会发生。
多态针对基类内部调用虚函数，在隐式的this此时关联到派生实例时也会发生。
#include <iostream>class Base
{
public:Base() {}virtual void fun(){printf("B_fun()\n");}void fun1(){printf("B_fun1()\n");fun();}virtual ~Base(){printf("~Base()\n");}protected:int m_pro;private:int m_pri;
};class A : public Base
{
public:A() : Base() {}void fun(){printf("A_fun()\n");}~A(){printf("~A()\n");}
};int main()
{A *pA = new A();Base *pB = pA;pB->fun1();delete pB;A a;Base &b = a;b.fun1();return 0;
}
3.封装
3.1.访问权限修饰符
a.c++支持的访问权限修饰符有public，protect，private。
b.在类型内部，针对类型自身所有成员（不含基类）具有全量（public，protect，private）访问权限。
c.在类型内部，针对类型基类，只能访问基类的public，protect修饰的成员。
c.在类型友元内部，具有等价于类型内部的访问权限。故对类型自身成员有全量访问权限，只能访问基类的public，protect修饰的成员。
d.在类型外部，针对类型自身成员，只对public成员具备访问权限。针对基类成员，只对public继承的基类的public成员具备访问权限。
#include <iostream>class Base
{// 类的友元--全量访问friend void friend_fun();
public:Base(int i, int j, int k) : m_pub(i), m_pro(j), m_pri(k) {}void fun(){// 类内部访问--全量访问printf("pub_%d,pro_%d,pri_%d\n", m_pub, m_pro, m_pri);}public:int m_pub;
protected:int m_pro;
private:int m_pri;
};class A1 : public Base
{friend void friend_funA1();public:A1(int i, int j, int k) : Base(i, j, k) {}void fun1(){// 公共继承者的内部--只能访问公共基类的public&protectprintf("pub_%d,pro_%d,pri_%d\n", m_pub, m_pro, 0);}
};// 保护继承
class A2 : protected Base
{friend void friend_funA2();
public:A2(int i, int j, int k) : Base(i, j, k) {}void fun1(){// 保护继承者的内部--只能访问保护基类的public&protectprintf("pub_%d,pro_%d,pri_%d\n", m_pub, m_pro, 0);}
};// 私有继承
class A3 : private Base
{friend void friend_funA3();public:A3(int i, int j, int k) : Base(i, j, k) {}void fun1(){// 私有继承者的内部--只能访问私有基类的public&protectprintf("pub_%d,pro_%d,pri_%d\n", m_pub, m_pro, 0);}
};void friend_fun()
{// 友元的内部--对类型自身成员全量访问Base b(1, 2, 3);printf("pub_%d,pro_%d,pri_%d\n", b.m_pub, b.m_pro, b.m_pri);
}void friend_funA1()
{// 友元的内部--对基类，公共基类的public&protectA1 b(1, 2, 3);printf("pub_%d,pro_%d,pri_%d\n", b.m_pub, b.m_pro);
}void friend_funA2()
{// 友元的内部--对基类，保护基类的public&protectA2 b(1, 2, 3);printf("pub_%d,pro_%d,pri_%d\n", b.m_pub, b.m_pro);
}void friend_funA3()
{// 友元的内部----对基类，私有基类的public&protectA3 b(1, 2, 3);printf("pub_%d,pro_%d,pri_%d\n", b.m_pub, b.m_pro, 0);
}int main()
{Base b(11, 22, 33);// 类不相干的外部--针对类自身成员，只能访问类自身的public成员。b.m_pub;A1 a1(2, 3, 4);// 类不相干的外部--针对类基类成员，只能访问公共基类自身的public成员。printf("pub_%d,pro_%d,pri_%d\n", a1.m_pub, 0, 0);// 类不相干的外部--针对类基类成员，只能访问公共基类自身的public成员。A2 a2(3, 4, 5);printf("pub_%d,pro_%d,pri_%d\n", 0, 0, 0);// 类不相干的外部--针对类基类成员，只能访问公共基类自身的public成员。A3 a3(4, 5, 6);printf("pub_%d,pro_%d,pri_%d\n", 0, 0, 0);
}
理解继承时，对基类的权限修饰。可以认为是指定基类成员被合并到派生类成员时，允许放入的权限区域。
对public继承，允许被放入public，protect，private区域。所以，按基类成员一致权限放入。
对protect继承，允许被放入protect，private区域。所以，基类public，protect成员放入protect区域；private成员放入private区域。
对private继承，允许被放入private区域。所以，基类成员一致放入private区域。
