2014 0416 word清楚项目黑点 输入矩阵 普通继承和虚继承 函数指针实现多态 强弱类型语言

1、word 如何清除项目黑点

选中文字区域，选择开始->样式->全部清除

2、公式编辑器输入矩阵

先输入方括号，接着选择格式->中间对齐，然后点下面红色框里的东西，组后输入数据

 

3、vptr虚指针    vtbl虚函数表   vbtbl  虚基表

4、普通继承例子

#include<iostream>
using namespace std;
class A   
{   
};  

class B   
{
    char ch;   
    virtual void func0()  {  } 
}; 

class C  
{
    char ch1;
    char ch2;
    virtual void func()  {  }  
    virtual void func1()  {  } 
};

class D: public A, public C
{   
    char d;   
    virtual void func()  {  } 
    virtual void func1()  {  }
};   

class E: public B, public C
{   
    int e;   
    virtual void func0()  {  } 
    virtual void func1()  {  }
};

int main(void)
{
    cout<<"A="<<sizeof(A)<<endl;    //result=1
    cout<<"B="<<sizeof(B)<<endl;    //result=8    
    cout<<"C="<<sizeof(C)<<endl;    //result=8
    cout<<"D="<<sizeof(D)<<endl;    //result=12  注意
    cout<<"E="<<sizeof(E)<<endl;    //result=20  注意有两个虚函数指针
    return 0;
}

sizeof(E)=20，其在内存中的分布：

class Derived size(20):
     +---
     | +--- (base class B)
 | | {vfptr}
 | | ch
     | +---
     | +--- (base class C)
 | | {vfptr}
 | | ch1 ch2
    | +---
 | e
    +---
    +--- (virtual base CommonBase)
    +---

前面三个A、B、C类的内存占用空间大小就不需要解释了，注意一下内存对齐就可以理解了。
求sizeof(D)的时候，需要明白，首先VPTR指向的虚函数表中保存的是类D中的两个虚函数的地址，然后存放基类C中的两个数据成员ch1、ch2，注意内存对齐，然后存放数据成员d，这样4+4+4=12。
求sizeof(E)的时候，首先是类B的虚函数地址，然后类B中的数据成员，再然后是类C的虚函数地址，然后类C中的数据成员，最后是类E中的数据成员e，同样注意内存对齐，这样4+4+4+4+4=20。

5、虚继承与普通继承对比

虚继承代码如下：

#include<iostream>
using namespace std;
class CommonBase
{
  int co;    

  int co1;    

  int co2;    
};

class Base1: virtual public CommonBase//虚继承1处
{
public:
    virtual void print1() {  }
    virtual void print2() {  }
private:
    int b1;
};

class Base2: virtual public CommonBase//虚继承2处
{
public:
    virtual void dump1() {  }
    virtual void dump2() {  }
private:
    int b2;
};

class Derived: public Base1, public Base2
{
public:
    void print2() {  }
    void dump2() {  }
private:
    int d;
};

int main(void)
{
    cout<<sizeof(CommonBase)<<endl;//4
    cout<<sizeof(Base1)<<endl;//24
    cout<<sizeof(Base2)<<endl;//24
    cout<<sizeof(Derived)<<endl;//40
    return 0;
}

• sizeof(Derived)=40，其在内存中分布的情况如下：

class Derived size(40):
     +---
     | +--- (base class Base1)
 | | {vfptr}//4字节
 | | {vbptr}//4字节
 | | b1//4字节
     | +---
     | +--- (base class Base2)
 | | {vfptr}//4字节
 | | {vbptr}//4字节
 | | b2//4字节
    | +---
 | d//4字节
    +---
    +--- (virtual base CommonBase)
 | co//4字节

 | co1//4字节

 | co2//4字节+---

• 如果把上述代码中的1,2两处的virtual删除，那么得到的结果sizeof(Derived)是44>40(commonBase类越大，虚继承的的作用就越大)，内存示意图如下：

class Derived size(44):
     +---
     | +--- (base class Base1)
 | | {vfptr}     //4字节     
| | b1+---      //4字节

 +---

+--- (base class CommonBase) 

| co             //4字节
 | co1             //4字节 

| co2             //4字节

| +---
     | +--- (base class Base2)
 | | {vfptr}         //4字节
| | b2//4字节

 +---

+--- (base class CommonBase) 

| co//4字节

 | co1 //4字节

 | co2//4字节

 | +---
 | d//4字节
+---

6、也可以用函数指针实现多态

#include<iostream>
using namespace std;

typedef void (*fVoid)( );//函数指针

class A
{
public:
    static void test()
    {
        printf("hello A\n");
    }

    fVoid print;

    A()
    {
        print = A::test;
    }
};

class B : public A
{
public:
    static void test()
    {
        printf("hello B\n");
    }

    B()
    {
        print = B::test;
    }
};


int main(void)
{
    A aa;
    aa.print();

    B b;
    A* a = &b;  

    a->print();//函数指针实现多态

    return 0;
}

7、共有继承，子类和父类出现同样名称的变量

8、强类型语言和弱类型语言