C++类构造/继承/虚拟指针

1. C++类

class CBase
{
public:
	int ipub;
	virtual int funcPub() { return ipub; }
	virtual int funcPrt() { return iprt; }
	virtual int funcPrv() { return iprv; }
protect:
	int iprt;
private:
	int iprv;
}

class CDrived: public CBase
{
public：
	virtual int funcPub() { return ipub; }
	virtual int funcPrt() { return iprt; }
	virtual int funcPrv() { return iprv; }
}

int main()
{
	CBase objBase;
	CDrived objDrived;
}

以class标识符开头，成员有public/protect/private三种属性中的一个。
public成员：基类内能访问，基类对象能访问，派生类内能访问，派生类对象能访问。

objBase.funcPub(); // 正确
objBase.ipub; // 正确
objDrived.funcPub(); // 正确
objDrived.ipub; // 正确

protect成员：基类内能访问，基类对象不能访问，派生类内能访问，派生类对象不能访问。

objBase.funcPrt(); // 正确
objBase.iprt; // 错误
objDrived.funcPrt(); // 正确
objDrived.iprt; // 错误

private成员：基类内能访问，基类对象不能访问，派生类内不能访问，派生类对象不能访问。

objBase.funcPrv(); // 正确
objBase.iprv; // 错误
objDrived.funcPrv(); // 错误
objDrived.iprv; // 错误

2. 构造/拷贝/赋值/析构函数

class CBase
{
public:
	CBase(); // 构造函数，可重载
	CBase(const CBase& ); // 拷贝构造函数
	CBase& operator=(const CBase& ); // 赋值运算符
	~CBase(); // 析构函数
	CBase* operator&(); // 取址运算符
	const CBase* operator&() const; // 取址运算符
}

拷贝构造和赋值的区别在于，拷贝构造函数产生了新对象，赋值未产生新对象。

class A;
A a;
A b = a; // 拷贝构造函数，产生了新对象
A c;
c = a; // 赋值函数，未产生新对象

构造函数和拷贝构造函数调用次数之和等于析构函数调用的次数。

3. 继承

class CBase
{
public:
	int ipub;
protect:
	int iprt;
private:
	int iprv;
}
// 公有继承
class CDrivedPub: public CBase   // public: ipub
{								 // protect: iprt
}								 // private: 无
// 保护继承
class CDrivedPrt: protect CBase  // public: 无
{								 // protect: ipub，iprt
}								 // private: 无
// 私有继承
class CDrivedPrv: private CBase  // public: 无
{								 // protect: 无
}								 // private: ipub，iprt

4. 虚函数表实现细节

C++中利用虚函数表来实现多态机制。

// 基类1
class CBase1
{
public:
	virtual void f11();
	virtual void f12();
	virtual void f13();
	int b11;
private:
	int b12;
}

基类1的数据存储结构为：

// 基类2
class CBase2
{
public:
	virtual void f21();
	virtual void f22();
	virtual void f23();
	int b21;
private:
	int b22;
}

基类2的数据存储结构为：

// 派生类1
class CDrived1: public CBase1
{
public:
	virtual void f11();
	virtual void f14();
private:
	int d1;
}

派生类1的数据存储结构为：

// 派生类2
class CDrived1: public CBase1, public CBase2
{
public:
	virtual void f11();
	virtual void f22();
	virtual void f33();
private:
	int d2;
}

派生类2的数据存储结构为：