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&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区域。
