绝对不要以多态方式处理数组

关于结构体对齐的几条规则：

• 第一个成员在结构体变量偏移量为0的地址处；
• 其他成员变量要对齐到某个数字【对齐数=min(编译器对齐数，该成员的大小)】的整数倍地址处；
• 结构体总大小就为最大对齐的整数倍；
• 如果嵌套了结构体变量，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小就是所有对齐数（含嵌套结构体的对齐数）的整数倍。

#pragma pack(4)   //设置对齐数，N为1，2，4，8，16。默认为8
class A {
public:
	A()
	{
		m_iA = 0.0;
		cout << "A::A()" << endl;
	}
	~A()
	{
		cout << "A::~A()" << endl;
	}

    void Func1(){}         //普通函数不占用内存
    virtual void Func(){}  //指定虚函数的虚函数表的入口地址，占用4个字节
private:
	int m_iA;      //min(4,4):4 \ min(4,8):4 \ min(4,16):4
    static int m_iTotal;   //静态变量不占用内存，原因是编译器将其放在全局变量区
};

class B : public A{
public:
	B()
	{
        m_cB = 'a';
		m_iB = 0;
		m_fB = 0.0;
		m_dB = 0.0;
	}
	~B()
	{
		cout << "B::~B()" << endl;
	}
private:
	float m_fB;    //min(4,4):4 \ min(4,8):4 \ min(4,16):4
	double m_dB;   //min(8,4):4 \ min(8,8):8 \ min(8,16):8
    char m_cB;     //min(1,4):1 \ min(1,8):1 \ min(1,16):1
	int m_iB;      //min(4,4):4 \ min(4,8):4 \ min(4,16):4
};
#pragma pack() //恢复默认对齐数

//4字节对齐的情况下，最大对齐数是4
int size_A = sizeof(struct A) = 4 + 4（虚指针） = 8;
int size_B = sizeof(struct B) = A + 4 + 8 + 1 + (3) + 4 = 28;

//8字节对齐的情况下，最大对齐数是8
int size_A = sizeof(struct A) = 4 + 4 = 8;
int size_B = sizeof(struct B) = A + 4 + (4) + 8 + 1 + (3) + 4 = 32;

//16字节对齐的情况下，最大对齐数是8
int size_A = sizeof(struct A) = 4 + 4 = 8;
int size_B = sizeof(struct B) = A + 4 + (4) + 8 + 1 + (3) + 4 = 32;

        B类继承于A类，通过操作符sizeof(A)和sizeof(B)可知得到二者大小是不一样的，因此如果以多态方式处理数组，就会有误。

void PrintfArray(ostream& os, const A array[], int numArray)
{
    for(i : numArray)
    {
        os << array[i] << endl;        
    }
}

A array[10];
PrintfArray(os,array,10);//运行良好，因为第二个参数实参和形参类型一致

B array[10];
PrintfArray(os,array,10);//error,运行结果不可预期

        原因：array[i]其实是一个“指针算术表达式”的简写，它代表的其实是*(array +i)。array是个指针，指向数组的起始处。array所指的内存和array + i所指的内存两者相距等于i * sizeof(数组中对象)，编译器认为对象大小是sizeof(A)，但实际传入的对象时B对象，大小为sizeof(B)，因此编译器会被误导出错。

        通常情况，derived classes比其base classes有更多的data members，所以derived class objects比base class objects大。

void deleteArray(A array[])
{
    delete [] array;
}

B* bArray = new B[10];
deleteArray(bArray);  //删除数组

        执行deleteArray函数时，实际上数组中的每一个元素的destructor都必须被调用，因此会产生类似下面的语句，

for(i : numArray)
{
    array[i].A::~A();  //调用析构函数
}

        后果就是无法执行B类的析构函数。

        因此，综上原因，不允许以多态方式处理数组。