午夜国产欧美理论在线播放,欧美一级久久久,久久综合色88

ivy-jie — Sun, 28 Jun 2009 04:04:00 GMT

题目要求:
用C�~�写�E�序�q�注�?br>N*N矩阵输出
N=3时输�?br>1 2 3
8 9 4
7 6 5
N�Q?时输�?br>   1 2 3   4
   12 13 14 5
   11 16 15 6
   10 9 8 7

�~�写当N时的输出

代码:
#include
#include
#include

enum {
        MASK_UP                = 1,
        MASK_DOWN        = 2,
        MASK_LEFT        = 4,
        MASK_RIGHT        = 8,

        TURN_NONE        = 0,
        TURN_UP                = 1,
        TURN_DOWN        = 2,
        TURN_LEFT        = 3,
        TURN_RIGHT        = 4,
};

int directs[5][2] = {
        {0, 0},                // 0:TURN_NONE
        {-1, 0},        // 1:TURN_UP
        {1, 0},                // 2:TURN_DOWN
        {0, -1},        // 3:TURN_LEFT
        {0, 1},                // 4:TURN_RIGHT
};

int rules[16] = {
        TURN_NONE,        // 0:none
        TURN_UP,        // 1:up
        TURN_DOWN,        // 2:down
        TURN_NONE,        // 3:invalid
        TURN_LEFT,        // 4:left
        TURN_LEFT,        // 5:left and up
        TURN_DOWN,        // 6:left and down
        TURN_NONE,        // 7:invalid
        TURN_RIGHT,        // 8:right
        TURN_UP,        // 9:right and up
        TURN_RIGHT,        // 10:right and down
        TURN_NONE,        // 11-15:invalid
};
int next_pos(int *matrix, int n, int i, int j, int *nexti, int *nextj)
{
        if (i == -1 || j == -1)
        {
                *nexti = 0;
                *nextj = 0;
                return 1;
        }
        int mask = 0;
        if (i - 1 >= 0 && matrix[(i - 1) * n + j] == 0)                // up ok
                mask |= MASK_UP;
        if (i + 1 <= n - 1 && matrix[(i + 1) * n + j] == 0)        // down ok
                mask |= MASK_DOWN;
        if (j - 1 >= 0 && matrix[i * n + (j - 1)] == 0)                // left ok
                mask |= MASK_LEFT;
        if (j + 1 <= n - 1 && matrix[i * n + (j + 1)] == 0)        // right ok
                mask |= MASK_RIGHT;

        int rule = rules[mask];
        int *direct = directs[rule];
        if (direct[0] == 0 && direct[1] == 0)
                return 0;
        *nexti = i + direct[0];
        *nextj = j + direct[1];
        return 1;
}

int main(int argc, char *argv[])
{
        if (argc != 2)
                return -1;
        int n = atoi(argv[1]);
        if (n <= 0)
                return -1;

        int *matrix = (int*)malloc(n * n * sizeof(int));
        memset(matrix, 0, n * n * sizeof(int));

        int i = -1;
        int j = -1;
        int value = 1;
        while (next_pos(matrix, n, i, j, &i, &j) != 0)
        {
                matrix[i * n + j] = value++;
        }

        for (i = 0; i < n; i++)
        {
                for (j = 0; j < n; j++)
                {
                        printf("%d", matrix[i * n + j]);
                        if (j != n - 1)
                                printf("\t");
                }
                printf("\n");
        }

        free(matrix);
        return 0;
}

ivy-jie 2009-06-28 12:04 发表评论

虚��承与虚基�cȝ��本质

ivy-jie — Mon, 08 Jun 2009 14:34:00 GMT

虚��承与虚基�cȝ��本质
    虚��承和虚基�cȝ��定义是非常的��单的�Q�同时也是非常容易判断一个��承是否是虚��?br>的，虽然�q�两个概�늚�定义是非常的��单明��的�Q�但是在C++语言中虚�l�承作�ؓ(f��)一个比较生
�?n��i)��但是又是�l�对必要的组成部份而存在着�Q��ƈ且其行�ؓ(f��)和模型均表现出和一般的�l�承体系
之间的巨大的差异�Q�包括访问性能上的差异�Q�，现在我们��来��d��的从语言、模型、性能�?br>应用�{�多个方面对虚��承和虚基�c�进行研�I��?br>    首先�q�是先给�?gu��)��l�承和虚基类的定义�?br>    虚��承：(x��)在��承定义中包含�?ji��n)virtual关键字的�l�承关系�Q?br>    虚基�c�：(x��)在虚�l�承体系中的通过virtual�l�承而来的基�c�，需要注意的是：(x��)
            struct CSubClass : public virtual CBase {}; 其中CBase�U�C��为CSubClass
            的虚基类�Q�而不是说CBase��是个虚基类�Q�因为CBase�q�可以不不是虚��承体�p?br>            中的基类�?br>    有了(ji��n)上面的定义后�Q�就可以开始虚�l�承和虚基类的本质研�I�了(ji��n)�Q�下面按照语法、语义�?br>模型、性能和应用五个方面进行全面的描述�?br>
    1. 语法
       语法有语�a�的本�w�的定义所军_��Q��M��上来说非常的��单，如下�Q?br>           struct CSubClass : public virtual CBaseClass {};
       其中可以采用public、protected、private三种不同的��承关键字�q�行修饰�Q�只�?br>       ��保包含virtual��可以了(ji��n)�Q�这样一来就形成�?ji��n)虚�l�承体系�Q�同时CBaseClass��成�?br>       �?ji��n)CSubClass的虚基类�?ji��n)�?br>       其实�q�没有那么的��单，如果出现虚��承体�pȝ��q�一步��承会(x��)出现什么样的状况呢�Q?br>       如下所�C�：(x��)
            /*
             * 带有数据成员的基�c?br>             */
            struct CBaseClass1
            {
                CBaseClass1( size_t i ) : m_val( i ) {}

                size_t m_val;
            };
            /*
             * 虚拟�l�承体系
             */
            struct CSubClassV1 : public virtual CBaseClass1
            {
                CSubClassV1( size_t i ) : CBaseClass1( i ) {}
            };
            struct CSubClassV2 : public virtual CBaseClass1
            {
                CSubClassV2( size_t i ) : CBaseClass1( i ) {}
            };
            struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
            {
                CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
            };
            struct CDiamondSubClass1 : public CDiamondClass1
            {
                CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
            };
       注意上面代码中的CDiamondClass1和CDiamondSubClass1两个�cȝ��构造函数初始化�?br>       表中的内宏V��可以发现其中均包含�?ji��n)虚基类CBaseClass1的初始化工作�Q�如果没有这
       个初始化语句��׃��(x��)��D��~�译旉��误，��Z��么会(x��)�q�样呢？一般情况下不是只要�?br>       CSubClassV1和CSubClassV2中包含初始化��可以了(ji��n)么？要解释该问题必须要明白虚
       �l�承的语义特征，所以参看下面语义部分的解释�?br>
    2. 语义
          在C++中虚函数必须要通过一�U�间接的�q�行�Ӟ��而不是编译时�Q�机制才能够�Ȁ�z�（
      调用�Q�的函数�Q�而虚�l�承也是必须在运行时才能够进行定位访问的一�U�体制。存在，
      但间接。其中关键就在于存在、间接和�׃�n�q�三�U�特征�?br>       对于虚函数而言�Q�这三个特征是很好理解的�Q�间接性表明了(ji��n)他必��d��q�行时根据实�?br>       的对象来完成函数��d��Q�共享性表象在基类�?x��)共享被子类重蝲后的虚函敎ͼ�其实指�?br>       相同的函数入口�?br>       对于虚��承而言�Q�这三个特征如何理解呢？存在卌��C��l�承体系和虚基类��实存在�Q?br>       间接性表明了(ji��n)在访问虚基类的成员时同样也必��通过某种间接机制来完成（下面模型
       中会(x��)讲到�Q�，�׃�n性表象在虚基�c�M��(x��)在虚�l�承体系中被�׃�n�Q�而不�?x��)出现多份拷贝�?br>       那现在可以解释语法小节中留下来的那个问题?sh��)��(ji��n)�?#8220;��Z��么一旦出��C��(ji��n)虚基�c�，��必
       ��d��每一个��承类中都必须包含虚基�cȝ��初始化语�?#8221;。由上面的分析可以知道，
       虚基�c�L��被共享的�Q�也��是在��承体�p�M��无论被��承多��次�Q�对象内存模型中均只�?br>       出现一个虚基类的子对象�Q�这和多�l�承是完全不同的�Q�，�q�样一来既然是�׃�n的那�?br>       每一个子�c�都不会(x��)独占�Q�但是总还是必��要有一个类来完成基�cȝ��初始化过�E�（因�ؓ(f��)
       所有的对象都必��被初始化，哪怕是默认的）(j��)�Q�同时还?sh��)��能够重复进行初始化�Q�那�?br>       底谁应该负责完成初始化呢�Q�C++标准中（也是很自然的�Q�选择在每一�ơ��承子�c�M��
       都必��M��写初始化语句�Q�因为每一�ơ��承子�c�d��能都�?x��)用来定义对象�?j��)�Q�而在最下层
       �l�承子类中实际执行初始化�q�程。所以上面在每一个��承类中都要书写初始化语句�Q?br>       但是在创建对象时�Q�而仅仅会(x��)在创建对象用的类构造函��C��实际的执行初始化语句�Q?br>       其他的初始化语句都会(x��)被压制不调用�?br>
    3. 模型
       ��Z��(ji��n)实现上面所说的三种语义含义�Q�在考虑对象的实现模型（也就是内存模型）(j��)时就
       很自然了(ji��n)。在C++中对象实际上��是一个连�l�的地址�I�间的语义代表，我们来分析虚
       �l�承下的内存模型�?br>       3.1. 存在
           也就是说在对象内存�(sh��)��必须要包含虚基类的完整子对象�Q�以便能够完成通过地址
           完成对象的标识。那么至于虚基类的子对象�?x��)存攑֜�对象的那个位�|�（头、中间�?br>           ��N��Q�则由各个编译器选择�Q�没有差别。（在VC8中无��基类被声明在什么位�|�，
           虚基�cȝ��子对象都�?x��)被攄��在对象内存的��N��Q?br>       3.2. 间接
           间接性表明了(ji��n)在直接虚基承子类中一定包含了(ji��n)某种指针�Q�偏�U�L��表格�Q�来完成�?br>           �q�子�c�访问虚基类子对象（或成员）(j��)的间接手�D�（因�ؓ(f��)虚基�c�d��对象是共享的�Q?br>           没有��定关系�Q�，至于采用何种手段��q��译器选择。（在VC8中在子类中放�|�了(ji��n)
           一个虚基类指针vbc�Q�该指针指向虚函数表中的一个slot�Q�该slot中存攑ֈ�虚基
           �c�d��对象的偏�U�量的负��|��实际上就是个以补码表�C�的int�c�d��的��|��在计��虚
           基类子对象首地址�Ӟ��需要将该偏�U�量取绝对值相加，�q�个主要是�ؓ(f��)�?ji��n)和虚�?br>           中只能存放虚函数地址�q�一要求相区别，因�ؓ(f��)地址是原码表�C�的无符号int�c�d��
           的��|��(j��)
       3.3. �׃�n
           �׃�n表明�?ji��n)在对象的内存空间中仅仅能够包含一份虚基类的子对象�Q��ƈ且通过
           某种间接的机制来完成�׃�n的引用关�p�R��在介绍完整个内容后�?x��)附上测试代码�?br>           体现�q�些内容�?br>    4. 性能
       �׃��有了(ji��n)间接性和�׃�n性两个特征，所以决定了(ji��n)虚��承体�p�M��的对象在讉K��时必�?br>       �?x��)在旉��和空间上与一般情冉|��较大不同�?br>       4.1. 旉��
           在通过�l�承�c�d��象访问虚基类对象中的成员�Q�包括数据成员和函数成员�Q�时�Q�都
           必须通过某种间接引用来完成，�q�样�?x��)增加引用寻址旉��Q�就和虚函数一��P��(j��)�Q?br>           其实��是调整this指针以指向虚基类对象�Q�只不过�q�个调整是运行时间接完成的�?br>           �Q�在VC8中通过打开汇编输出�Q�可以查�?.cod文�g中的内容�Q�在讉K��虚基�c�d��?br>           成员时会(x��)形成三条mov间接��d��语句�Q�而在讉K��一般��承类对象时仅仅只有一条mov
           帔R��直接��d��语句�Q?br>       4.2. �I�间
           �׃��׃�n所以不同在对象内存?sh��)��保存多份虚基类子对象的拯��Q�这栯��之多�l�承
           节省�I�间�?br>    5. 应用
       谈了(ji��n)那么多语�a��Ҏ(gu��)��和内容�Q�那么在什么情况下需要��用虚�l�承�Q�而一般应该如何��
       用呢�Q?br>       �q�个问题其实很难有答案，一般情况下如果你确性出现多�l�承没有必要�Q�必��要�׃�n
       基类子对象的时候可以考虑采用虚��承关�p�（C++标准ios体系��是�q�样的）(j��)。由于每
       一个��承类都必��d��含初始化语句而又仅仅只在最底层子类中调用，�q�样可能��׃��(x��)�?br>       得某些上层子�c�d��到的虚基�c�d��对象的状态不是自己所期望的（因�ؓ(f��)自己的初始化�?br>       句被压制�?ji��n)�?j��)�Q�所�?span style="COLOR: red">一般徏议不要在虚基�c�M��包含��M��数据成员�Q�不要有状态）(j��)�Q�只
       可以作�ؓ(f��)接口�c�L��提供�?br>               假定通过多个�z��路径�l�承名�ؓ(f��)X的成员，有下面三�U�可能性：(x��)

            1�Q�如果在每个路径中X表示同一虚基�c�L��员，则没有二义性，因�ؓ(f��)�׃�n该成员的单个实例�Q?br>            2�Q�如果在某个路径中X是虚基类的成员，而在另一路径中X是后代派生类的成员，也没有二义性——特定派生类实例的优先��高�(sh��)��׃�n虚基�c�d��例�?nbsp;
           3�Q�如果沿每个�l�承路径X表示后代�z��cȝ��不同成员�Q�则该成员的直接讉K��是二义性的�?br>

附录�Q�测试代�?br>#include
#include

/*
* 带有数据成员的基�c?br> */
struct CBaseClass1
{
    CBaseClass1( size_t i ) : m_val( i ) {}

    size_t m_val;
};
/*
* 虚拟�l�承体系
*/
struct CSubClassV1 : public virtual CBaseClass1
{
    CSubClassV1( size_t i ) : CBaseClass1( i ) {}
};

struct CSubClassV2 : public virtual CBaseClass1
{
    CSubClassV2( size_t i ) : CBaseClass1( i ) {}
};

struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
{
    CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
};

struct CDiamondSubClass1 : public CDiamondClass1
{
    CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
};
/*
* 正常�l�承体系
*/
struct CSubClassN1 : public CBaseClass1
{
    CSubClassN1( size_t i ) : CBaseClass1( i ) {}
};
struct CSubClassN2 : public CBaseClass1
{
    CSubClassN2( size_t i ) : CBaseClass1( i ) {}
};
struct CMultiClass1 : public CSubClassN1, public CSubClassN2
{
    CMultiClass1( size_t i ) : CSubClassN1( i ), CSubClassN2( i ) {}
};
struct CMultiSubClass1 : public CMultiClass1
{
    CMultiSubClass1( size_t i ) : CMultiClass1( i ) {}
};
/*
* 不带有数据成员的接口基类
*/
struct CBaseClass2
{
    virtual void func() {};
    virtual ~CBaseClass2() {}
};
/*
* 虚拟�l�承体系
*/
// struct CBaseClassX { CBaseClassX() {i1 = i2 = 0xFFFFFFFF;} size_t i1, i2;};
struct CSubClassV3 : public virtual CBaseClass2
{
};
struct CSubClassV4 : public virtual CBaseClass2
{
};
struct CDiamondClass2 : public CSubClassV3, public CSubClassV4
{
};
struct CDiamondSubClass2 : public CDiamondClass2
{
};

/*
* 正常�l�承体系
*/
struct CSubClassN3 : public CBaseClass2
{
};
struct CSubClassN4 : public CBaseClass2
{
};
struct CMultiClass2 : public CSubClassN3, public CSubClassN4
{
};
struct CMultiSubClass2 : public CMultiClass2
{
};

/*
* 内存布局用类声明.
*/
struct CLayoutBase1
{
    CLayoutBase1() : m_val1( 0 ), m_val2( 1 ) {}

    size_t m_val1, m_val2;
};
struct CLayoutBase2
{
    CLayoutBase2() : m_val1( 3 ) {}

    size_t m_val1;
};
struct CLayoutSubClass1 : public virtual CBaseClass1, public CLayoutBase1, public CLayoutBase2
{
    CLayoutSubClass1() : CBaseClass1( 2 ) {}
};

#define MAX_TEST_COUNT 1000 * 1000 * 16
#define TIME_ELAPSE() ( std::clock() - start * 1.0 ) / CLOCKS_PER_SEC

int main( int argc, char *argv[] )
{
    /*
     * �c�M��p�M��的尺�?
     */
    std::cout << "================================ sizeof ================================" << std::endl;
    std::cout << "    ----------------------------------------------------------------" << std::endl;
    std::cout << "sizeof( CBaseClass1 )       = " << sizeof( CBaseClass1 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassV1 )       = " << sizeof( CSubClassV1 ) << std::endl;
    std::cout << "sizeof( CSubClassV2 )       = " << sizeof( CSubClassV2 ) << std::endl;
    std::cout << "sizeof( CDiamondClass1 )    = " << sizeof( CDiamondClass1 ) << std::endl;
    std::cout << "sizeof( CDiamondSubClass1 ) = " << sizeof( CDiamondSubClass1 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassN1 )       = " << sizeof( CSubClassN1 ) << std::endl;
    std::cout << "sizeof( CSubClassN2 )       = " << sizeof( CSubClassN2 ) << std::endl;
    std::cout << "sizeof( CMultiClass1 )      = " << sizeof( CMultiClass1 ) << std::endl;
    std::cout << "sizeof( CMultiSubClass1 )   = " << sizeof( CMultiSubClass1 ) << std::endl;

    std::cout << "    ----------------------------------------------------------------" << std::endl;
    std::cout << "sizeof( CBaseClass2 )       = " << sizeof( CBaseClass2 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassV3 )       = " << sizeof( CSubClassV3 ) << std::endl;
    std::cout << "sizeof( CSubClassV4 )       = " << sizeof( CSubClassV4 ) << std::endl;
    std::cout << "sizeof( CDiamondClass2 )    = " << sizeof( CDiamondClass2 ) << std::endl;
    std::cout << "sizeof( CDiamondSubClass2 ) = " << sizeof( CDiamondSubClass2 ) << std::endl;
    std::cout << std::endl;
    std::cout << "sizeof( CSubClassN3 )       = " << sizeof( CSubClassN3 ) << std::endl;
    std::cout << "sizeof( CSubClassN4 )       = " << sizeof( CSubClassN4 ) << std::endl;
    std::cout << "sizeof( CMultiClass2 )      = " << sizeof( CMultiClass2 ) << std::endl;
    std::cout << "sizeof( CMultiSubClass2 )   = " << sizeof( CMultiSubClass2 ) << std::endl;
    /*
     * 对象内存布局
     */
    std::cout << "================================ layout ================================" << std::endl;
    std::cout << "    --------------------------------MI------------------------------" << std::endl;
    CLayoutSubClass1 *lsc = new CLayoutSubClass1;
    std::cout << "sizeof( CLayoutSubClass1 )   = " << sizeof( CLayoutSubClass1 ) << std::endl;
    std::cout << "CLayoutBase1 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase1 *)lsc - (char*)lsc << std::endl;
    std::cout << "CBaseClass1 offset of CLayoutSubClass1 is " << (char*)(CBaseClass1 *)lsc - (char*)lsc << std::endl;
    std::cout << "CLayoutBase2 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase2 *)lsc - (char*)lsc << std::endl;

    int *ptr = (int*)lsc;
    std::cout << "vbc in CLayoutSubClass1 is " << *(int*)ptr[3] << std::endl;

    delete lsc;

    std::cout << "    --------------------------------SI------------------------------" << std::endl;
    CSubClassV1 *scv1 = new CSubClassV1( 1 );
    std::cout << "sizeof( CSubClassV1 )   = " << sizeof( CSubClassV1 ) << std::endl;
    std::cout << "CBaseClass1 offset of CSubClassV1 is " << (char*)(CBaseClass1 *)scv1 - (char*)scv1 << std::endl;

    ptr = (int*)scv1;
    std::cout << "vbc in CSubClassV1 is " << *(int*)ptr[0] << std::endl;

    delete scv1;

    /*
     * 性能��试
     */
    std::cout << "================================ Performance ================================" << std::endl;
    double times[4];
    size_t idx = 0;

    CSubClassV1 *ptr1 = new CDiamondClass1( 1 );
    std::clock_t start = std::clock();
    {
        for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
            ptr1->m_val = i;
    }
    times[idx++] = TIME_ELAPSE();
    delete static_cast( ptr1 );

    CSubClassN1 *ptr2 = new CMultiClass1( 0 );
    start = std::clock();
    {
        for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
            ptr2->m_val = i;
    }
    times[idx++] = TIME_ELAPSE();
    delete static_cast( ptr2 );

    std::cout << "CSubClassV1::ptr1->m_val " << times[0] << " s" << std::endl;
    std::cout << "CSubClassN1::ptr2->m_val " << times[1] << " s" << std::endl;

    return 0;
}

��试环境�Q?br>    软�g环境�Q�Visual Studio2005 Pro + SP1, boost1.34.0
    ��g环境�Q�PentiumD 3.0GHz, 4G RAM
��试数据�Q?br>================================ sizeof ================================
    ----------------------------------------------------------------
sizeof( CBaseClass1 )       = 4

sizeof( CSubClassV1 )       = 8
sizeof( CSubClassV2 )       = 8
sizeof( CDiamondClass1 )    = 12
sizeof( CDiamondSubClass1 ) = 12

sizeof( CSubClassN1 )       = 4
sizeof( CSubClassN2 )       = 4
sizeof( CMultiClass1 )      = 8
sizeof( CMultiSubClass1 )   = 8
    ----------------------------------------------------------------
sizeof( CBaseClass2 )       = 4

sizeof( CSubClassV3 )       = 8
sizeof( CSubClassV4 )       = 8
sizeof( CDiamondClass2 )    = 12
sizeof( CDiamondSubClass2 ) = 12

sizeof( CSubClassN3 )       = 4
sizeof( CSubClassN4 )       = 4
sizeof( CMultiClass2 )      = 8
sizeof( CMultiSubClass2 )   = 8
================================ layout ================================
    --------------------------------MI------------------------------
sizeof( CLayoutSubClass1 )   = 20
CLayoutBase1 offset of CLayoutSubClass1 is 0
CBaseClass1 offset of CLayoutSubClass1 is 16
CLayoutBase2 offset of CLayoutSubClass1 is 8
vbc in CLayoutSubClass1 is -12
    --------------------------------SI------------------------------
sizeof( CSubClassV1 )   = 8
CBaseClass1 offset of CSubClassV1 is 4
vbc in CSubClassV1 is 0
================================ Performance ================================
CSubClassV1::ptr1->m_val 0.062 s
CSubClassN1::ptr2->m_val 0.016 s

�l�果分析�Q?br>    1. �׃��虚��承引入的间接性指针所以导致了(ji��n)虚��承类的尺�怼�(x��)增加4个字节；
    2. 由Layout输出可以看出�Q�虚基类子对象被攑֜��?ji��n)对象的��N��Q�偏�U�Mؓ(f��)16�Q�，�q�且vbc
       指针必须紧紧的接在虚基类子对象的前面�Q�所以vbc指针所指向的内容�ؓ(f��)“偏移 - 4”�Q?br>    3. �׃��VC8��偏�U�L��在了(ji��n)虚函数表中，所以�ؓ(f��)�?ji��n)区分函数地址和偏�U�，所以偏�U�L��用补
       码int表示的负��|��
    4. 间接性可以通过性能来看出，在虚�l�承体系同通过指针讉K��成员时的旉��一般是一�?br>       �c�访问情况下�?倍左叻I��W�合汇编语言输出文�g中的汇编语句的安排�?br>

ivy-jie 2009-06-08 22:34 发表评论

一道多�l�承和虚�l�承的面试题

ivy-jie — Mon, 08 Jun 2009 14:30:00 GMT

class A{
public A { std::cout<}

class B: public A{
... // print B
}

class C: public A, pulic B {
... // print C
}

int main(){
C obj;
}
输出: AABC。��承关�p�L��三角形：(x��)A->B->C加A->C�?br>
问题是：(x��)�q�三条边如果考虑虚��承，每条�Ҏ(gu��)��两种可能�Q�共八种。那么其他七�U�组合的
输出是什么�?
�~�译�? VC6.0
#include "stdafx.h"
#include "iostream"
using namespace std;
class AA {
public:
AA(){ std::cout<<"AA"<};
class BB: public virtual AA
{
public:
BB(){ std::cout<<"BB"<};

class CC: public virtual AA, public (virtual) BB //括号的virtual可有可无
{
public:
CC(){ std::cout<<"CC"<};

int main(int argc, char* argv[])
{
CC obj;

return 0;
}
输出: AA
BB
CC
其它情况�~�译�?x��)出�?br>主要考察多��承的虚基�c�d��内存?sh��)��只有一份copy,如果不用虚��承的话，�Ҏ(gu��)��造成二义性，�~�译不过:)

ivy-jie 2009-06-08 22:30 发表评论

ivy-jie — Sun, 24 May 2009 02:47:00 GMT

1、静(r��n)态全局变量

在全局变量前，加上关键字static�Q�该变量��p��定义成�ؓ(f��)一个静(r��n)态全局变量。我们先举一个静(r��n)态全局变量的例子，如下�Q?
//Example 1#include void fn();static int n; //定义�?r��n)态全局变量void main(){ n=20; cout<
�?r��n)态全局变量有以下特点：(x��)
该变量在全局数据�?/strong>分配内存�Q?
未经初始化的�?r��n)态全局变量�?x��)被�E�序自动初始化�ؓ(f��)0�Q�自动变量的值是随机的，除非它被昑ּ�初始化）(j��)�Q?
�?r��n)态全局变量在声明它的整个文仉��是可见的�Q�而在文�g之外是不可见的；
�?r��n)态变量都在全局数据区分配内存，包括后面��要提到的静(r��n)态局部变量。对于一个完整的�E�序�Q�在内存?sh��)��?br>
分布情况如下图：(x��)
代码�?
全局数据�?
堆区
栈区

一般程序的由new产生的动态数据存攑֜�堆区�Q�函数内部的自动变量存放在栈区。自动变量一般会(x��)随着函数的退�?gu��)��释攄��_(d��)��?r��n)态数据（即��是函数内部的�?态局部变量）(j��)也存攑֜�全局数据区。全局数据区的数据�q�不�?x��)因为函数的退�?gu��)��释攄��间。细�?j��)的读者可能会(x��)发现�Q�Example 1中的代码中将

static int n; //定义�?r��n)态全局变量
改�ؓ(f��)
int n; //定义全局变量
�E�序照样正常�q�行�?
的确�Q?strong>定义全局变量��可以实现变量在文�g中的�׃�n�Q�但定义�?r��n)态全局变量�q�有以下好处�Q?
�?r��n)态全局变量不能被其它文件所用；
其它文�g中可以定义相同名字的变量�Q�不�?x��)发生冲�H�；
�(zh��n)�可以将上述�C�Z��代码改�ؓ(f��)如下�Q?

//Example 2//File1#include void fn();static int n; //定义�?r��n)态全局变量void main(){ n=20; cout<extern int n;void fn(){ n++; cout<�~�译�q�运行Example 2�Q��?zh��n)��׃�?x��)发现上述代码可以分别通过�~�译�Q�但�q�行时出现错误�?试着��?
static int n; //定义�?r��n)态全局变量
改�ؓ(f��)
int n; //定义全局变量
再次�~�译�q�行�E�序�Q�细�?j��)体会(x��)全局变量和静(r��n)态全局变量的区别�?
2、静(r��n)态局部变�?

在局部变量前�Q�加上关键字static�Q�该变量��p��定义成�ؓ(f��)一个静(r��n)态局部变量�?

我们先�D一个静(r��n)态局部变量的例子�Q�如下：(x��)

//Example 3#include void fn();void main(){ fn(); fn(); fn();}void fn(){ static n=10; cout<通常�Q�在函数体内定义�?ji��n)一个变量，每当�E�序�q�行到该语句旉��?x��)给该局部变量分配栈内存。但随着�E�序退出函��C��Q�系�l�就�?x��)收回栈内存�Q�局部变量也相应失效�?
但有时候我们需要在两次调用之间对变量的��D��行保存。通常的想法是定义一个全局变量来实现。但�q�样一来，变量已经不再属于函数本��n�?ji��n)，不再仅受函数的控�Ӟ��l�程序的�l�护带来不便�?
�?r��n)态局部变量正好可以解册��个问题。静(r��n)态局部变量保存在全局数据区，而不是保存在栈中�Q�每�ơ的��g��持到下一�ơ调用，直到下次赋新倹{�?
�?r��n)态局部变量有以下特点�Q?

该变量在全局数据区分配内存；
�?r��n)态局部变量在�E�序执行到该对象的声明处时被首次初始化，即以后的函数调用不再�q�行初始化；
�?r��n)态局部变量一般在声明处初始化�Q�如果没有显式初始化�Q�会(x��)被程序自动初始化�?�Q?
它始�l�驻留在全局数据区，直到�E�序�q�行�l�束。但�?span style="COLOR: #000000">作用域�ؓ(f��)局部作用域�Q�当定义它的函数或语句块�l�束�Ӟ��其作用域随之�l�束�Q?
3、静(r��n)态函�?

在函数的�q�回�c�d��前加上static关键�?函数卌��定义为静(r��n)态函数。静(r��n)态函��C��普通函��C��同，它只能在声明它的文�g当中可见�Q�不能被其它文�g使用�?

�?r��n)态函数的例子�Q?

//Example 4#include static void fn();//声明�?r��n)态函数void main(){ fn();}void fn()//定义�?r��n)态函数{ int n=10; cout<定义�?r��n)态函数的好处�Q?
�?r��n)态函��C��能被其它文�g所用；
其它文�g中可以定义相同名字的函数�Q�不�?x��)发生冲�H�；

ivy-jie 2009-05-24 10:47 发表评论

ivy-jie — Sun, 24 May 2009 02:42:00 GMT

�?r��n)态类成员包括�?r��n)态数据成�?/font>�?font color=#ff0000>�?r��n)态函数成�?/font>两部分�?nbsp;

1 �?r��n)态数据成员：(x��)


      �c�M��中的数据成员的声明前加上static关键字，该数据成员就成�ؓ(f��)�?ji��n)该�cȝ��?r��n)态数据成�?/font>。和其他数据成员?sh��)��P��?r��n)态数据成�?/font>也遵�?font color=#3366ff>public/protected/private讉K��规则。同�Ӟ��?r��n)态数据成�?/font>�q�具有以下特点：(x��)

1.�?r��n)态数据成员的定义�?
�?r��n)态数据成员实际上是类域中的全局变量。所以，�?r��n)态成员�(sh��)��能在�c�d��义里边初始化�Q�只能在class body外初始化�?/font>    举例如下�Q?

xxx.h文�g
class base{
private:
static const int _i;//声明�Q�标准c++支持有序�c�d��在类体中初始�?但vc6不支持�?
};

xxx.cpp文�g
const int base::_i=10;//定义(初始�?时不受private和protected讉K��限制.


        2.�?r��n)态数据成�?/font>�?font color=#ff0000>�c?/font>的所有对象所�׃�n�Q�包括该�c�L��生类的对象�?/span>��x(ch��ng)��生类对象与基�c�d��象共享基�cȝ��?r��n)态数据成员�?nbsp;

        3 初始�?或定�?�Q�访问方�?br>
         �?r��n)态数据成员初始化的格式�ؓ(f��)�Q?
        �Q�数据类型＞�Q�类名＞::�Q�静(r��n)态数据成员名�Q?�Q��|��
       �cȝ��?r��n)态数据成员有两种讉K��形式�Q?
        �Q�类对象名＞.�Q�静(r��n)态数据成员名�Q?�?�Q�类�c�d��名＞::�Q�静(r��n)态数据成员名�Q?
     如果�?r��n)态数据成员的讉K��权限允许的话�Q?span style="COLOR: red">即public的成�?/strong>�Q�，可在�E�序中，按上�q�格式来引用�?r��n)态数据成�?nbsp;;


       3.�?r��n)态数据成�?/font>可以成�ؓ(f��)成员函数的可选参敎ͼ�而普通数据成员则不可以。�D例如下：(x��)
class base{
public :
static int _staticVar;
int _var;
void foo1(int i=_staticVar);//正确,_staticVar为静(r��n)态数据成�?/font>
void foo2(int i=_var);//错误,_var为普通数据成�?/font>
};

    4.�?font style="COLOR: #000000" color=#ff0000>�?r��n)态数据成�?/font>的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明�?nbsp;所属类�c�d��的指针或引用。�D例如下：(x��)

class base{
public :
static base _object1;//正确�Q�静(r��n)态数据成�?
base _object2;//错误
base *pObject;//正确�Q�指�?
base &mObject;//正确�Q�引�?
};

5.★这个特性，我不知道是属于标准c++中的�Ҏ(gu��)��，�q�是vc6自己的特性�?
�?r��n)态数据成员的值在const成员函数中可以被合法的改变。�D例如下：(x��)

class base{
public:
base(){_i=0;_val=0;}

mutable int _i;
static int _staticVal;
int _val;
void test() const{//const 成员函数

_i++;//正确�Q�mutable数据成员
_staticVal++;//正确�Q�static数据成员
_val++;//错误

}
};
int base::_staticVal=0;

2 �?r��n)态成员函�?/strong>

      1.�?r��n)态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用 �c�L��员函数指针来储存。�D例如下：(x��)
class base{
static int func1();
int func2();
};

int (*pf1)()=&base::func1;//普通的函数指针
int (base::*pf2)()=&base::func2;//成员函数指针

    2.�?r��n)态成员函��C��可以调用�cȝ��非静(r��n)态成员�?u>因�ؓ(f��)�?r��n)态成员函��C��含this指针�?/strong>
     通常情况下，this 是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，�?r��n)态成员函数由于不是与��M��的对象相联系�Q�因此它不具有this�?针。从�q�个意义上讲�Q?span style="COLOR: red">它无法访问属于类对象的非�?r��n)态数据成�?/strong>�Q?span style="COLOR: red">也无法访问非�?r��n)态成员函�?/strong>�Q�它只能调用其余的静(r��n)态成员函�?/strong>�?nbsp;

      3.�?r��n)态成员函��C��可以同时声明�? virtual、const、volatile函数。�D例如下：(x��)
class base{
virtual static void func1();//错误
static void func2() const;//错误
static void func3() volatile;//错误
              };

3   �?r��n)态构造函�?br>     �?r��n)态构造函数自动被调用�Q�不能被昑ּ�调用。虽然提供了(ji��n)许多�U�束条�g�Q�但是静(r��n)态构造函数执行的��切旉��和顺序是不确定的�Q?br>一个类的静(r��n)态构造函数在�q�个�cȝ��M��实例被创建前执行�?br>一个类的静(r��n)态构造函数在�cȝ��M��?r��n)态成员被引用前执行�?br>一个类的静(r��n)态构造函数在它的所有派生类的静(r��n)态构造函数执行之后执行�?br>一个类的静(r��n)态构造函��C��不会(x��)被执行一�ơ以上�?br>

ivy-jie 2009-05-24 10:42 发表评论

ivy-jie — Fri, 22 May 2009 16:27:00 GMT

子类�l�承和调用父�cȝ��构造方�?/p>

1.如果子类没有定义构造方�?则调用父�cȝ��无参数的构造方�?.

2.如果子类定义�?ji��n)构造方�?不论是无参数�q�是带参�?在创建子�cȝ��对象的时�?首先执行父类无参数的构造方�?/strong>,然后执行自己的构造方法�?/p>
3.如果子类调用父类带参数的构造方�?可以通过super(参数)调用所需要的父类的构造方�?切该语句做�ؓ(f��)子类构造方法中的第一条语�?/span>�?/p>
4.如果某个构造方法调用类中的其他的构造方�?则可以用this(参数),切该语句攑֜�构造方法的�W�一�?

说白�?原则��是,先调用父亲的.(没有��默认调,有了(ji��n)��按有的�?反正只要有一个就可以�?)

package test;

class Father{

String s = "Run constructor method of Father";

public Father(){

   System.out.println(s);

}

public Father(String str){

   s= str;

   System.out.println(s);

}

}

class Son extends Father{

String s= "Run constructor method of son";

public Son(){

   //实际上在�q�里加上super()�Q�和没加是一个样�?/p>
   System.out.println(s);

}

public Son(String str){

   this();//�q�里调用this()表示调用本类的Son(),因�ؓ(f��)Son()中有�?ji��n)一个super()�?ji��n)，所以这里不能再加了(ji��n)�?/p>
   s = str;

   System.out.println(s);

}

public Son(String str1, String str2){

   super(str1+" "+str2);//因�ؓ(f��)�q�里已经调用�?ji��n)一个父�cȝ��带参数的super("---")�?ji��n)，所以不�?x��)再自动调用了(ji��n)无参数的�?ji��n)�?/p>
   s = str1;

   System.out.println(s);

}

}

public class MyClass9 {

public static void main(String[] args){

   Father obfather1 = new Father();

   Father obfather2 = new Father("Hello Father");

   Son obson1 = new Son();

   Son obson2 = new Son("hello son");

   Son obson3 = new Son("hello son","hello father");



}

}

===============

�l�果:

Run constructor method of Father

Hello Father

Run constructor method of Father

Run constructor method of son

Run constructor method of Father

Run constructor method of son

hello son

hello son hello father

hello son

ivy-jie 2009-05-23 00:27 发表评论

输入函数scanf()详解

ivy-jie — Fri, 22 May 2009 01:01:00 GMT
1 �׃��scanf函数在接收数据时�Q�是通过�I�格来区分数据项�?
如果你：(x��)
char c[20];
scanf("%s",c);
输入:this is a c program!

它接收到this后遇到空��|��认�ؓ(f��)对应%s的数据项已结束，后面的（包含�I�格�Q�不能输入�?
你想输入带空格的字符�Ԍ��只有使用gets(c);
但遗憄��是用gets()函数一�ơ只能输入一个字�W�串�?br> 2 �ȝ��
%d,遇到数字,'+','-'以外的字�W�结�?可蟩�q�空�?

%f,,%lf:遇到数字, '.', 'e','+','-'之外的字�W�结�?可蟩�q�空�?br>
%s,从第一个非�I�格字符��L(f��ng)��C��一个空格结�?

%c,遇到字符��p��?不管是空��D��是回车之�cȝ��.

假如�E�序中出现这��L(f��ng)��代码,scanf("%d,%s,%c,%c").虽然�E�序是以 ', '作�ؓ(f��)分隔�?�?s是不认这�?', '�?它只认空�?所以会(x��)出现变量不能正确赋值的情况,如果你将','��L��,但由�?c却遇到空格又不会(x��)跌��,所以也不会(x��)满��需�?通过上面的我们知�?%c遇到�I�格是不�?x��)蟩�q�的,所以我采取下面�q�个方式来解�?�?c的前面加一个空格来处理,�q�样��可以解决上面的所有问题�(sh��)��(ji��n),所以我们在使用%c�?要在前面加上一个空�?/span>,��L��q�种�?f��n)惯可以省去不少�ȝ�?ch��),�q�且在��?c之前最好还加上一�?span style="COLOR: #ff0000">fflush(stdin);用来清除�~�存.
3 gets()
   功能:从stdin��中��d��字符�Ԍ��直至接受到换行符或EOF时停止，�q�将��d��的结果存攑֜�str指针所指向的字�W�数�l�中。换行符不作��取串的内容，��d��的换行符被�{换�ؓ(f��)null��|��q�由此来�l�束字符丌Ӏ?br>   注意:本函数可以无限读取，不会(x��)判断上限�Q�所以程序员应该��保str的空间��够大�Q�以便在执行��L��作时不发生溢出�?br>   实例�Q?include"stdio.h"
                  void main()
                   {
                            char str[15];
                            gets(str);
                            printf("%s/n",str);

                   }

ivy-jie 2009-05-22 09:01 发表评论

�?qsort七种应用

ivy-jie — Mon, 18 May 2009 15:52:00 GMT
七种qsort排序�Ҏ(gu��)��

<本文中排序都是采用的从小到大排序>

一、对int�c�d��数组排序

int num[100];

Sample:

int cmp ( const void *a , const void *b )
{
return *(int *)a - *(int *)b;
}

qsort(num,100,sizeof(num[0]),cmp);

二、对char�c�d��数组排序�Q�同int�c�d��Q?

char word[100];

Sample:

int cmp( const void *a , const void *b )
{
return *(char *)a - *(int *)b;
}

qsort(word,100,sizeof(word[0]),cmp);

三、对double�c�d��数组排序�Q�特别要注意�Q?

double in[100];

int cmp( const void *a , const void *b )
{
return *(double *)a > *(double *)b ? 1 : -1;
}

qsort(in,100,sizeof(in[0]),cmp)�Q?

四、对�l�构体一�U�排�?

struct In
{
double data;
int other;
}s[100]

//按照data的��g��到大将�l�构体排�?关于�l�构体内的排序关键数据data的类型可以很多种�Q�参考上面的例子�?

int cmp( const void *a ,const void *b)
{
return (*(In *)a).data > (*(In *)b).data ? 1 : -1;
}

qsort(s,100,sizeof(s[0]),cmp);

五、对�l�构体二�U�排�?

struct In
{
int x;
int y;
}s[100];

//按照x从小到大排序�Q�当x相等时按照y从大到小排序

int cmp( const void *a , const void *b )
{
struct In *c = (In *)a;
struct In *d = (In *)b;
if(c->x != d->x) return c->x - d->x;
else return d->y - c->y;
}

qsort(s,100,sizeof(s[0]),cmp);

六、对字符串进行排�?

struct In
{
int data;
char str[100];
}s[100];

//按照�l�构体中字符串str的字兔R��序排�?

int cmp ( const void *a , const void *b )
{
return strcmp( (*(In *)a)->str , (*(In *)b)->str );
}

qsort(s,100,sizeof(s[0]),cmp);

七、计��几何中求凸包的cmp

int cmp(const void *a,const void *b) //重点cmp函数�Q�把除了(ji��n)1点外的所有点�Q�旋转角度排�?
{
struct point *c=(point *)a;
struct point *d=(point *)b;
if( calc(*c,*d,p[1]) < 0) return 1;
else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) //如果在一条直�U�上�Q�则把远的放在前�?
return 1;
else return -1;
}

PS:

其中的qsort函数包含�?lt;stdlib.h>的头文�g里，strcmp包含�?lt;string.h>的头文�g�?

ivy-jie 2009-05-18 23:52 发表评论

C++��言1:�l�不在构造或析构期调用虚函数

ivy-jie — Mon, 18 May 2009 09:26:00 GMT
你不应该在构造或析构期间调用虚函敎ͼ�因�ؓ(f��)�q�样的调用不�?x��)如你想象那样工作，而且它们做的事情保证�?x��)让你很郁闷�?假设你有一套模拟股��处理的�c�d��ơ结构，例如�Q�购入流�E�，出售?hu��)��程�{�。对�q�样的处理来说可以核查是非常重要的，所以随时会(x��)创徏一�?Transaction 对象�Q�将�q�个创徏记录在核查日志中是一个适当的要求。下面是一个看��h��g��合理的解决问题的�Ҏ(gu��)��Q?br>

class Transaction { // base class for all
　public: // transactions
　　Transaction();

　　virtual void logTransaction() const = 0; // make type-dependent
　　// log entry
　　...
};

Transaction::Transaction() // implementation of
{
　// base class ctor
　...
　logTransaction(); // as final action, log this
} // transaction

class BuyTransaction: public Transaction {
　// derived class
　public:
　　virtual void logTransaction() const; // how to log trans-
　　// actions of this type
　　...
};

class SellTransaction: public Transaction {
// derived class
public:
　virtual void logTransaction() const; // how to log trans-
　// actions of this type
...
};

　　考虑执行�q�行代码时会(x��)发生什么：(x��)

BuyTransaction b;

　　很明�?BuyTransaction 的构造函��C��(x��)被调用，但是首先�Q�Transaction 的构造函数必��d��被调用，�z��c�d��象中的基�c�部分先于派生类部分被构造。Transaction 的构造函数的最后一行调用虚函数 logTransaction�Q�但是结果会(x��)让你大吃一惊，被调用的 logTransaction 版本是在 Transaction 中的那个�Q�而不�?BuyTransaction 中的——即使被创徏的对象类型是 BuyTransaction。基�c�L��造期��_(d��)��虚函��C��来不�?x��)向下匹配（go down�Q�到�z��c�R��取而代之的是，那个对象的行为就好像它的�c�d��是基�c�R��非正式地讲�Q?span style="COLOR: #ff0000">基类构造期��_(d��)��虚函数禁�?/span>�?�q�个表面上看��h��匪夷所思的行�ؓ(f��)存在一个很好的理由。因为基�cȝ��构造函数在�z��c�L��造函��C��前执行，当基�c�L��造函数运行时�Q�派生类数据成员�q�没有被初始化。如果基�c�L��造期间调用的虚函数向下匹配（go down�Q�到�z��c�，�z��cȝ��函数理所当然�?x��)涉及(qi��ng)到本地数据成员�Q�但是那些数据成员还没有被初始化。这��׃��(x��)为未定义行�ؓ(f��)和�?zh��n)�之晚矣的调试噩梦开�?ji��n)一张通行�?/span>。调用涉�?qi��ng)到一个对象还没有被初始化的部分自然是危险的，所�?C++ 告诉你此路不通�?br>      在实际上�q�有比这更多的更深层�ơ的原理。在�z��c�d��象的基类构造期��_(d��)��对象的类型是那个基类的�?span style="COLOR: #ff0000">不仅虚函��C��(x��)解析到基�c�，而且语言中用到运行时�c�d��信息�Q�runtime type information�Q�的配�g�Q�例如，dynamic_cast�?typeid�Q�，也会(x��)��对象视为基�cȝ��型�?/span>在我们的例子中，�?Transaction 构造函数运行初始化 BuyTransaction 对象的基�c�部分时�Q�对象的�c�d��?Transaction。C++ 的每一个配件将以如下眼光来看待它，�q�对它��生这��L(f��ng)��感觉�Q�对象的 BuyTransaction �Ҏ(gu��)��的部分还没有被初始化�Q�所以安全的对待它们的方法就是视若无睏V��在�z��c�L��造函数运行之前，一个对象不�?x��)成��Z��个派生类对象�?br>
　　同样的原因也适用于析构过�E�。一旦派生类析构函数�q�行�Q�这个对象的�z��c�L��据成员就被视为未定义的��|��所�?C++ ��将它们视�ؓ(f��)不再存在。在�q�入基类析构函数�Ӟ��对象��成��Z��个基�c�d��象，C++ 的所有配件——虚函数�Q�dynamic_casts �{�——都如此看待它�?

ivy-jie 2009-05-18 17:26 发表评论

ivy-jie — Mon, 18 May 2009 01:26:00 GMT
    C++中的虚函数的作用主要是实��C��(ji��n)多态的机制。关于多态，��而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子�cȝ��成员函数。这�U�技术可以让父类的指针有“多种形�?#8221;�Q�这是一�U�泛型技术。所谓泛型技术，说白�?ji��n)就是试图��用不变的代码来实现可变的��法。比如：(x��)模板技术，RTTI技术，虚函数技术，要么是试囑ց�到在�~�译时决议，要么试图做到�q�行时决议�?br>1 虚函数表
    虚函敎ͼ�Virtual Function�Q�是通过一张虚函数表（Virtual Table�Q�来实现的。简�U�Cؓ(f��)V-Table�?在这个表中，��L��要一个类的虚函数的地址表，�q�张表解决了(ji��n)�l�承、覆盖的问题�Q�保证其容真实反应实际的函数。这��P��在有虚函数的�cȝ��实例中这个表被分配在�?�q�个实例的内存�(sh��)��Q�所以，当我们用父类的指针来操作一个子�cȝ��时候，�q�张虚函数表��显得由为重要了(ji��n)�Q�它?y��u)��像一个地图一��P��指明�?ji��n)实际所应该调用的函数�?
    �q�里我们着重看一下这张虚函数表。在C++的标准规��D��明书中说刎ͼ��~�译器必需要保证虚函数表的指针存在于对象实例中最前面的位�|�（�q�是��Z��(ji��n)保证正确取到虚函数的偏移量）(j��)�?�q�意味着我们通过对象实例的地址得到�q�张虚函数表�Q�然后就可以遍历其中函数指针�Q��ƈ调用相应的函数�?
2 代码�Q?br>#include
#include
#include
typedef void (*Fun) (void);
class Base{
public:
virtual void f() {cout<<"Base::f"< virtual void g() {cout<<"Base::g"< virtual void h() {cout<<"Base::h"<};
void main(int argc,char * argv[])
{
Base b;
Fun pFun = NULL;
int *var1= (int *)&b;
cout<<"虚函数表地址:"< int *var2 = (int*)*(int*)(&b);
cout<<"虚函数表-�W�一个函数地址:"<< var2 << endl;//(int*)*(int*)(&b)
//Invoke the first virtual function
pFun = (Fun)*((int*)*(int*)(&b)+0); //f()
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+1); //g()
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+2); // h()
pFun();
}
//�l�果
虚函数表地址:0x0012FF7C
虚函数表-�W�一个函数地址:0x0042804C
Base::f
Base::g
Base::h

ivy-jie 2009-05-18 09:26 发表评论

函数指针实现回调

ivy-jie — Mon, 18 May 2009 00:40:00 GMT
void (*p) (); //p是指向某函数的指�?br> p是指向某函数的指针，该函数无输入参数�Q�返回值的�c�d��为void。左边圆括弧里星号后的就是指针变量名。有�?ji��n)指针变量便可以赋��|��值的内容是��v名匹配的函数名和�q�回�c�d��。例如：(x��)

void func()
{
/* do something */
}
p = func;

p的赋值可以不同，但一定要是函数的地址�Q��ƈ且��v名和�q�回�c�d��相同�?br>
传递回调函数的地址�l�调用�?br>
现在可以��p传递给另一个函敎ͼ�调用者）(j��)- caller()�Q�它?y��u)��调用p指向的函敎ͼ�而此函数名是未知的：(x��)

void caller(void(*ptr)())
{
ptr(); /* 调用ptr指向的函�?*/
}
void func();
int main()
{
p = func;
caller(p); /* 传递函数地址到调用�?*/
}

    如果赋了(ji��n)不同的值给p�Q�不同函数地址�Q�，那么调用者将调用不同地址的函数。赋值可以发生在�q�行�Ӟ��q�样使你能实现动态绑定�?br>
调用规范

    到目前�ؓ(f��)止，我们只讨��Z��(ji��n)函数指针�?qi��ng)回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几�U�调用规范。如在Visual C++中，可以在函数类型前加_cdecl�Q�_stdcall或者_pascal来表�C�其调用规范�Q�默认�ؓ(f��)_cdecl�Q�。C++ Builder也支持_fastcall调用规范。调用规范媄(ji��ng)响编译器产生的给定函数名�Q�参��C��递的��序�Q�从叛_��左或从左到右�Q�，堆栈清理责�Q�Q�调用者或者被调用者）(j��)以及(qi��ng)参数传递机�Ӟ��堆栈�Q�CPU寄存器等�Q��?br>
    ��调用规范看成是函数�c�d��的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：(x��)

// 被调用函数是以int为参敎ͼ�以int��回�?br>__stdcall int callee(int);

// 调用函数以函数指针�ؓ(f��)参数
void caller( __cdecl int(*ptr)(int));

// 在p中企囑֭�储被调用函数地址的非法操�?br>__cdecl int(*p)(int) = callee; // 出错

    指针p和callee()的类型不兼容�Q�因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p�Q�尽��两者有相同的返回值和参数列�?

ivy-jie 2009-05-18 08:40 发表评论

午夜国产欧美理论在线播放,欧美一级久久久,久久综合色88

虚��承与虚基�cȝ��本质

一道多�l�承和虚�l�承的面试题

输入函数scanf()详解

�?qsort七种应用

C++���言1:�l�不在构造或析构期调用虚函数

函数指针实现回调

C++��言1:�l�不在构造或析构期调用虚函数