#include <iostream>
using namespace std;

class CBase
{
public:
    CBase()
    {
        cout<<"I in Base constructor"<<endl;
    }
    virtual ~CBase()
    {
        cout<<"I in Base deconstructor"<<endl;
    }
};

class CDerived : public CBase
{
public:
    CDerived()
    {
        cout<<"I in CDerived constructor"<<endl;
    }
    virtual ~CDerived()
    {
        cout<<"I in CDerived deconstructor"<<endl;
    }
};


int main()
{

    CBase *pBase = new CDerived();
    delete pBase;

    return 0;
}

输出结果

I in Base constructor
I in CDerived constructor
I in CDerived deconstructor
I in Base deconstructor

      以前一直觉得virtual的指定是可有可无的，现在才知道，如果不制定virutal，那么I in CDerived deconstructor就不会调用。这个与construtor完全不一样，事实上也正是这样把他/它忽略了。

      接着就要想想如何实现的呢？

先来看看构造函数
004012CF   .  894D F0       mov     [ebp-10], ecx
004012D2   .  8B4D F0       mov     ecx, [ebp-10]
004012D5   .  E8 D0FDFFFF   call    004010AA                                    ; 调用基类的构造函数
004012DA   .  C745 FC 00000>mov     dword ptr [ebp-4], 0
004012E1   .  8B45 F0       mov     eax, [ebp-10]
004012E4   .  C700 3C204300 mov     dword ptr [eax], offset CDerived::`vftable'
004012EA   .  68 2D104000   push    0040102D
004012EF   .  68 1C204300   push    0043201C                                       ;  ASCII "I in CDerived constructor"
004012F4   .  68 40954300   push    offset std::cout
004012F9   .  E8 CAFDFFFF   call    004010C8
和以前理解的一样，不多解释

下面是析构函数(注意这里是CDerived生成的delete函数哦)

00401069   . /E9 32040000   jmp     CDerived::`scalar deleting destructor'

004014BA  |.  894D FC       mov     [ebp-4], ecx
004014BD  |.  8B4D FC       mov     ecx, [ebp-4]
004014C0  |.  E8 F9FBFFFF   call    004010BE                              ; 调用子类的析构函数
004014C5  |.  8B45 08       mov     eax, [ebp+8]
004014C8  |.  83E0 01       and     eax, 1
004014CB  |.  85C0          test    eax, eax
004014CD  |.  74 0C         je      short 004014DB
004014CF  |.  8B4D FC       mov     ecx, [ebp-4]
004014D2  |.  51            push    ecx                                            ; /Arg1
004014D3  |.  E8 A8130000   call    operator delete                                ; \operator delete

0040153F   .  894D F0       mov     [ebp-10], ecx
00401542   .  8B45 F0       mov     eax, [ebp-10]
00401545   .  C700 3C204300 mov     dword ptr [eax], offset CDerived::`vftable'
0040154B   .  C745 FC 00000>mov     dword ptr [ebp-4], 0
00401552   .  68 2D104000   push    0040102D
00401557   .  68 80204300   push    00432080                                       ;  ASCII "I in CDerived disconstructor"
0040155C   .  68 40954300   push    offset std::cout
00401561   .  E8 62FBFFFF   call    004010C8
00401566   .  83C4 08       add     esp, 8
00401569   .  8BC8          mov     ecx, eax
0040156B   .  E8 1CFBFFFF   call    0040108C
00401570   .  C745 FC FFFFF>mov     dword ptr [ebp-4], -1
00401577   .  8B4D F0       mov     ecx, [ebp-10]
0040157A   .  E8 E0FAFFFF   call    0040105F                                       ; 基类的析构函数

结论：
编译器不能自动识别析构函数，必须要多态的标识。

#include <stdio.h>
#include <memory.h>
#include <stdlib.h>

int  n,m;
char DNA[100][100] = {0};

int calc_unsortedness(const char *pDNA, int length)
{
    int  i;
    char a;
    int  left_C = 0, left_G = 0, left_T = 0;
    int  count  = 0;
    
    for(i = length-1; i >= 0; i--)
    {
        a = pDNA[i];
        switch(a)
        {
        case 'A':
            left_C++;
            left_G++;
            left_T++;
            break;
        case 'C':
            left_G++;
            left_T++;
            count+=left_C;
            break;
        case 'G':
            left_T++;
            count+=left_G;
            break;
        case 'T':
            count+=left_T;
            break;
        }
    }
    return count;
}

int compare(const void *arg1, const void *arg2)
{
    return calc_unsortedness((const char *)arg1, n) - calc_unsortedness((const char *)arg2, n);
}

int main()
{
    int i;
    
    scanf("%d %d\n", &n, &m); 
    //memset(DNA, 0, sizeof(DNA));
    for (i = 0; i < m; ++i)
        gets(DNA[i]);
    
    qsort((void *)DNA, m, sizeof(char) * 100, compare);
    
    for (i = 0; i < m; ++i)
        puts(DNA[i]);
    
    return 0;
}

好久没做题了，今天回来得早。就把前几天看了的这题给实现了。AC的历程很奇怪。

首先是include了<search.h> ，结果: CE
接着是搞错了n和m，把DNA定义为 char DNA[50][100]  结果 : RTE
然后将他们倒了过来,就变成了OLE
百思不得其解，最后定义char DNA[100][100]，就AC了

#include "iostream"
using namespace std;


class A
{
    int a;
public:
    virtual void Fun(int n)
    {
        a = n;
        cout<<"This is in A : "<<a<<endl;
    }
};

class B : public A
{
    int b;
public:
    virtual void Fun(int n)
    {
        b = n;
        cout<<"This is in B : "<<b<<endl;
    }
};

class C : public A
{
    int c;
public:
    virtual void Fun(int n)
    {
        c = n;
        cout<<"This is in C : "<<c<<endl;
    }
};

class D : public B, public C
{
    int d;
public:
    virtual void Fun(int n)
    {
        d = n;
        cout<<"This is in D : "<<d<<endl;
    }
};


int main()
{
    D d;
    d.Fun(3);
    return 0;
}

先来看看多重继承的对象组织的结构


实际上，多重继承vc都将它解释为这个结构。但是多重集成中实际在内存中的组织是很不一样的

00B606D8  0046F020  offset test3.D::`vftable'
00B606DC  CDCDCDCD    A::a
00B606E0  CDCDCDCD    B::b
00B606E4  0046F01C  offset test3.D::`vftable'
00B606E8  CDCDCDCD   A::a
00B606EC  CDCDCDCD  C::c
00B606F0  CDCDCDCD  D::d

note:
   按照道理来说两个offset test3.D::`vftable'应该指向同一个地方才对，可这里是？

   第二个offset test3.D::`vftable'指向的位置是第二篇讲过的跳转函数！

2.虚继承

#include "iostream"
using namespace std;


class A
{
    int a;
public:
    virtual void Fun(int n)
    {
        a = n;
        cout<<"This is in A : "<<a<<endl;
    }
};

class B : virtual  public  A
{
    int b;
public:
    virtual void Fun(int n)
    {
        b = n;
        cout<<"This is in B : "<<b<<endl;
    }
};

class C :virtual  public  A
{
    int c;
public:
    virtual void Fun(int n)
    {
        c = n;
        cout<<"This is in C : "<<c<<endl;
    }
};

class D : public  B, public  C
{
    int d;
public:
    virtual void Fun(int n)
    {
        d = n;
        cout<<"This is in D : "<<d<<endl;
    }
};


int main()
{
    D *pd = new D;
    pd->Fun(sizeof(D));
    return 0;
}

00A806D8  0046F02C  offset test3.D::`vbtable'
00A806DC  CDCDCDCD   B::b
00A806E0  0046F020  offset test3.D::`vbtable'
00A806E4  CDCDCDCD   C::c
00A806E8  CDCDCDCD   A::a
00A806EC  0046F01C  offset test3.D::`vftable'
00A806F0  CDCDCDCD  D::d

第一和第二个offset test3.D::`vbtable' 指向一个偏移跳转表，它的表中用偏移指向了真正的offset test3.D::`vbtable'，第三个是真正的offset test3.D::`vbtable'地址

0046F01C >004011A9  test3.004011A9  第三个offset test3.D::`vbtable'
0046F020 >00000000                               第二个offset test3.D::`vbtable' 
0046F024  0000000C                               偏移C
0046F028  00000000
0046F02C >00000000                               第一个offset test3.D::`vbtable'
0046F030  00000014                                便宜14