1.面向对象指的是继承，封装，多态。
继承主要关注类的构造，赋值，析构。
以下对多态，封装进行补充说明。

2、多态
2.1.定义
a.赋值
派生类的指针，可以赋值给基类的指针。
派生类的对象，可以赋值给基类的引用。
b.调用
通过基类指针调用基类虚函数时，若派生类提供了派生实现，则调用派生类版本。
通过基类引用调用基类虚函数时，若派送类提供了派送实现，则调用派生类版本。

2.2.最佳实践
基类的析构函数应该定义成虚函数。

#include <iostream> class Base { public: Base() { fun(); } 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; }

2.3. 注意点
多态针对类外部使用基类指针或基类引用调用基类虚函数时会发生。
多态针对基类内部调用虚函数，在隐式的this此时关联到派生实例时也会发生。
值得注意的是：在基类的构造函数中，this永远都关联到基类自身．只有在基类的非构造函数中，this才有可能被关联到派生类实例并引发多态访问．

#include <iostream> class Base { public: Base() { fun(); } 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&protect printf("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&protect printf("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&protect printf("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&protect A1 b(1, 2, 3); printf("pub_%d,pro_%d,pri_%d\n", b.m_pub, b.m_pro); } void friend_funA2() { // 友元的内部--对基类，保护基类的public&protect A2 b(1, 2, 3); printf("pub_%d,pro_%d,pri_%d\n", b.m_pub, b.m_pro); } void friend_funA3() { // 友元的内部----对基类，私有基类的public&protect A3 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区域。