C++博客-ivy-jie-文章分类-c++

有意思的矩阵输出题

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

题目要求:
用C编写程序并注释
N*N矩阵输出
N=3时输出
1 2 3
8 9 4
7 6 5
N＝4时输出
   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 发表评论

虚继承与虚基类的本质

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

虚继承与虚基类的本质
    虚继承和虚基类的定义是非常的简单的，同时也是非常容易判断一个继承是否是虚继承
的，虽然这两个概念的定义是非常的简单明确的，但是在C++语言中虚继承作为一个比较生
僻的但是又是绝对必要的组成部份而存在着，并且其行为和模型均表现出和一般的继承体系
之间的巨大的差异（包括访问性能上的差异），现在我们就来彻底的从语言、模型、性能和
应用等多个方面对虚继承和虚基类进行研究。
    首先还是先给出虚继承和虚基类的定义。
    虚继承：在继承定义中包含了virtual关键字的继承关系；
    虚基类：在虚继承体系中的通过virtual继承而来的基类，需要注意的是：
            struct CSubClass : public virtual CBase {}; 其中CBase称之为CSubClass
            的虚基类，而不是说CBase就是个虚基类，因为CBase还可以不不是虚继承体系
            中的基类。
    有了上面的定义后，就可以开始虚继承和虚基类的本质研究了，下面按照语法、语义、
模型、性能和应用五个方面进行全面的描述。

    1. 语法
       语法有语言的本身的定义所决定，总体上来说非常的简单，如下：
           struct CSubClass : public virtual CBaseClass {};
       其中可以采用public、protected、private三种不同的继承关键字进行修饰，只要
       确保包含virtual就可以了，这样一来就形成了虚继承体系，同时CBaseClass就成为
       了CSubClass的虚基类了。
       其实并没有那么的简单，如果出现虚继承体系的进一步继承会出现什么样的状况呢？
       如下所示：
            /*
             * 带有数据成员的基类
             */
            struct CBaseClass1
            {
                CBaseClass1( size_t i ) : m_val( i ) {}

                size_t m_val;
            };
            /*
             * 虚拟继承体系
             */
            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两个类的构造函数初始化列
       表中的内容。可以发现其中均包含了虚基类CBaseClass1的初始化工作，如果没有这
       个初始化语句就会导致编译时错误，为什么会这样呢？一般情况下不是只要在
       CSubClassV1和CSubClassV2中包含初始化就可以了么？要解释该问题必须要明白虚
       继承的语义特征，所以参看下面语义部分的解释。

    2. 语义
          在C++中虚函数必须要通过一种间接的运行时（而不是编译时）机制才能够激活（
      调用）的函数，而虚继承也是必须在运行时才能够进行定位访问的一种体制。存在，
      但间接。其中关键就在于存在、间接和共享这三种特征。
       对于虚函数而言，这三个特征是很好理解的，间接性表明了他必须在运行时根据实际
       的对象来完成函数寻址，共享性表象在基类会共享被子类重载后的虚函数，其实指向
       相同的函数入口。
       对于虚继承而言，这三个特征如何理解呢？存在即表示虚继承体系和虚基类确实存在，
       间接性表明了在访问虚基类的成员时同样也必须通过某种间接机制来完成（下面模型
       中会讲到），共享性表象在虚基类会在虚继承体系中被共享，而不会出现多份拷贝。
       那现在可以解释语法小节中留下来的那个问题了，“为什么一旦出现了虚基类，就必
       须在每一个继承类中都必须包含虚基类的初始化语句”。由上面的分析可以知道，
       虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中均只会
       出现一个虚基类的子对象（这和多继承是完全不同的），这样一来既然是共享的那么
       每一个子类都不会独占，但是总还是必须要有一个类来完成基类的初始化过程（因为
       所有的对象都必须被初始化，哪怕是默认的），同时还不能够重复进行初始化，那到
       底谁应该负责完成初始化呢？C++标准中（也是很自然的）选择在每一次继承子类中
       都必须书写初始化语句（因为每一次继承子类可能都会用来定义对象），而在最下层
       继承子类中实际执行初始化过程。所以上面在每一个继承类中都要书写初始化语句，
       但是在创建对象时，而仅仅会在创建对象用的类构造函数中实际的执行初始化语句，
       其他的初始化语句都会被压制不调用。

    3. 模型
       为了实现上面所说的三种语义含义，在考虑对象的实现模型（也就是内存模型）时就
       很自然了。在C++中对象实际上就是一个连续的地址空间的语义代表，我们来分析虚
       继承下的内存模型。
       3.1. 存在
           也就是说在对象内存中必须要包含虚基类的完整子对象，以便能够完成通过地址
           完成对象的标识。那么至于虚基类的子对象会存放在对象的那个位置（头、中间、
           尾部）则由各个编译器选择，没有差别。（在VC8中无论虚基类被声明在什么位置，
           虚基类的子对象都会被放置在对象内存的尾部）
       3.2. 间接
           间接性表明了在直接虚基承子类中一定包含了某种指针（偏移或表格）来完成通
           过子类访问虚基类子对象（或成员）的间接手段（因为虚基类子对象是共享的，
           没有确定关系），至于采用何种手段由编译器选择。（在VC8中在子类中放置了
           一个虚基类指针vbc，该指针指向虚函数表中的一个slot，该slot中存放则虚基
           类子对象的偏移量的负值，实际上就是个以补码表示的int类型的值，在计算虚
           基类子对象首地址时，需要将该偏移量取绝对值相加，这个主要是为了和虚表
           中只能存放虚函数地址这一要求相区别，因为地址是原码表示的无符号int类型
           的值）
       3.3. 共享
           共享表明了在对象的内存空间中仅仅能够包含一份虚基类的子对象，并且通过
           某种间接的机制来完成共享的引用关系。在介绍完整个内容后会附上测试代码，
           体现这些内容。
    4. 性能
       由于有了间接性和共享性两个特征，所以决定了虚继承体系下的对象在访问时必然
       会在时间和空间上与一般情况有较大不同。
       4.1. 时间
           在通过继承类对象访问虚基类对象中的成员（包括数据成员和函数成员）时，都
           必须通过某种间接引用来完成，这样会增加引用寻址时间（就和虚函数一样），
           其实就是调整this指针以指向虚基类对象，只不过这个调整是运行时间接完成的。
           （在VC8中通过打开汇编输出，可以查看*.cod文件中的内容，在访问虚基类对象
           成员时会形成三条mov间接寻址语句，而在访问一般继承类对象时仅仅只有一条mov
           常量直接寻址语句）
       4.2. 空间
           由于共享所以不同在对象内存中保存多份虚基类子对象的拷贝，这样较之多继承
           节省空间。
    5. 应用
       谈了那么多语言特性和内容，那么在什么情况下需要使用虚继承，而一般应该如何使
       用呢？
       这个问题其实很难有答案，一般情况下如果你确性出现多继承没有必要，必须要共享
       基类子对象的时候可以考虑采用虚继承关系（C++标准ios体系就是这样的）。由于每
       一个继承类都必须包含初始化语句而又仅仅只在最底层子类中调用，这样可能就会使
       得某些上层子类得到的虚基类子对象的状态不是自己所期望的（因为自己的初始化语
       句被压制了），所以一般建议不要在虚基类中包含任何数据成员（不要有状态），只
       可以作为接口类来提供。
               假定通过多个派生路径继承名为X的成员，有下面三种可能性：

            1）如果在每个路径中X表示同一虚基类成员，则没有二义性，因为共享该成员的单个实例；
            2）如果在某个路径中X是虚基类的成员，而在另一路径中X是后代派生类的成员，也没有二义性——特定派生类实例的优先级高于共享虚基类实例。
           3）如果沿每个继承路径X表示后代派生类的不同成员，则该成员的直接访问是二义性的。

附录：测试代码
#include
#include

/*
* 带有数据成员的基类
*/
struct CBaseClass1
{
    CBaseClass1( size_t i ) : m_val( i ) {}

    size_t m_val;
};
/*
* 虚拟继承体系
*/
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 ) {}
};
/*
* 正常继承体系
*/
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() {}
};
/*
* 虚拟继承体系
*/
// 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
{
};

/*
* 正常继承体系
*/
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[] )
{
    /*
     * 类体系中的尺寸.
     */
    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;
}

测试环境：
    软件环境：Visual Studio2005 Pro + SP1, boost1.34.0
    硬件环境：PentiumD 3.0GHz, 4G RAM
测试数据：
================================ 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

结果分析：
    1. 由于虚继承引入的间接性指针所以导致了虚继承类的尺寸会增加4个字节；
    2. 由Layout输出可以看出，虚基类子对象被放在了对象的尾部（偏移为16），并且vbc
       指针必须紧紧的接在虚基类子对象的前面，所以vbc指针所指向的内容为“偏移 - 4”；
    3. 由于VC8将偏移放在了虚函数表中，所以为了区分函数地址和偏移，所以偏移是用补
       码int表示的负值；
    4. 间接性可以通过性能来看出，在虚继承体系同通过指针访问成员时的时间一般是一般
       类访问情况下的4倍左右，符合汇编语言输出文件中的汇编语句的安排。

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

一道多继承和虚继承的面试题

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。继承关系是三角形：A->B->C加A->C。

问题是：这三条边如果考虑虚继承，每条边有两种可能，共八种。那么其他七种组合的
输出是什么。
编译器: 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
其它情况编译会出错
主要考察多继承的虚基类在内存中只有一份copy,如果不用虚继承的话，容易造成二义性，编译不过:)

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

面向过程的静态成员

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

1、静态全局变量

在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下：
//Example 1#include void fn();static int n; //定义静态全局变量void main(){ n=20; cout<
静态全局变量有以下特点：
该变量在全局数据区分配内存；
未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）；
静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；
静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的

分布情况如下图：
代码区
全局数据区
堆区
栈区

一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现，Example 1中的代码中将

static int n; //定义静态全局变量
改为
int n; //定义全局变量
程序照样正常运行。
的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：
静态全局变量不能被其它文件所用；
其它文件中可以定义相同名字的变量，不会发生冲突；
您可以将上述示例代码改为如下：

//Example 2//File1#include void fn();static int n; //定义静态全局变量void main(){ n=20; cout<extern int n;void fn(){ n++; cout<编译并运行Example 2，您就会发现上述代码可以分别通过编译，但运行时出现错误。试着将
static int n; //定义静态全局变量
改为
int n; //定义全局变量
再次编译运行程序，细心体会全局变量和静态全局变量的区别。
2、静态局部变量

在局部变量前，加上关键字static，该变量就被定义成为一个静态局部变量。

我们先举一个静态局部变量的例子，如下：

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

该变量在全局数据区分配内存；
静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；
静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；
它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；
3、静态函数

在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

静态函数的例子：

//Example 4#include static void fn();//声明静态函数void main(){ fn();}void fn()//定义静态函数{ int n=10; cout<定义静态函数的好处：
静态函数不能被其它文件所用；
其它文件中可以定义相同名字的函数，不会发生冲突；

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

面向对象的静态成员

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

静态类成员包括静态数据成员和静态函数成员两部分。

1 静态数据成员：


      类体中的数据成员的声明前加上static关键字，该数据成员就成为了该类的静态数据成员。和其他数据成员一样，静态数据成员也遵守public/protected/private访问规则。同时，静态数据成员还具有以下特点：

1.静态数据成员的定义。
静态数据成员实际上是类域中的全局变量。所以，静态成员不能在类定义里边初始化，只能在class body外初始化。    举例如下：

xxx.h文件
class base{
private:
static const int _i;//声明，标准c++支持有序类型在类体中初始化,但vc6不支持。
};

xxx.cpp文件
const int base::_i=10;//定义(初始化)时不受private和protected访问限制.


        2.静态数据成员被类的所有对象所共享，包括该类派生类的对象。即派生类对象与基类对象共享基类的静态数据成员。

        3 初始化(或定义)，访问方式

         静态数据成员初始化的格式为：
        ＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞
       类的静态数据成员有两种访问形式：
        ＜类对象名＞.＜静态数据成员名＞或＜类类型名＞::＜静态数据成员名＞
     如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ;


       3.静态数据成员可以成为成员函数的可选参数，而普通数据成员则不可以。举例如下：
class base{
public :
static int _staticVar;
int _var;
void foo1(int i=_staticVar);//正确,_staticVar为静态数据成员
void foo2(int i=_var);//错误,_var为普通数据成员
};

    4.★静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为所属类类型的指针或引用。举例如下：

class base{
public :
static base _object1;//正确，静态数据成员
base _object2;//错误
base *pObject;//正确，指针
base &mObject;//正确，引用
};

5.★这个特性，我不知道是属于标准c++中的特性，还是vc6自己的特性。
静态数据成员的值在const成员函数中可以被合法的改变。举例如下：

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

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

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

}
};
int base::_staticVal=0;

2 静态成员函数

      1.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用类成员函数指针来储存。举例如下：
class base{
static int func1();
int func2();
};

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

    2.静态成员函数不可以调用类的非静态成员。因为静态成员函数不含this指针。
     通常情况下，this 是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。

      3.静态成员函数不可以同时声明为 virtual、const、volatile函数。举例如下：
class base{
virtual static void func1();//错误
static void func2() const;//错误
static void func3() volatile;//错误
              };

3   静态构造函数
     静态构造函数自动被调用，不能被显式调用。虽然提供了许多约束条件，但是静态构造函数执行的确切时间和顺序是不确定的：
一个类的静态构造函数在这个类的任何实例被创建前执行。
一个类的静态构造函数在类的任何静态成员被引用前执行。
一个类的静态构造函数在它的所有派生类的静态构造函数执行之后执行。
一个类的静态构造函数从不会被执行一次以上。

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

子类父类构造函数调用顺序

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

子类继承和调用父类的构造方法

1.如果子类没有定义构造方法,则调用父类的无参数的构造方法,.

2.如果子类定义了构造方法,不论是无参数还是带参数,在创建子类的对象的时候,首先执行父类无参数的构造方法,然后执行自己的构造方法。

3.如果子类调用父类带参数的构造方法,可以通过super(参数)调用所需要的父类的构造方法,切该语句做为子类构造方法中的第一条语句。

4.如果某个构造方法调用类中的其他的构造方法,则可以用this(参数),切该语句放在构造方法的第一条.

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

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(){

//实际上在这里加上super()，和没加是一个样的

System.out.println(s);

}

public Son(String str){

this();//这里调用this()表示调用本类的Son(),因为Son()中有了一个super()了，所以这里不能再加了。

s = str;

System.out.println(s);

}

public Son(String str1, String str2){

super(str1+" "+str2);//因为这里已经调用了一个父类的带参数的super("---")了，所以不会再自动调用了无参数的了。

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");

}

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

结果:

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函数在接收数据时，是通过空格来区分数据项的.
如果你：
char c[20];
scanf("%s",c);
输入:this is a c program!

它接收到this后遇到空格，认为对应%s的数据项已结束，后面的（包含空格）不能输入。
你想输入带空格的字符串，只有使用gets(c);
但遗憾的是用gets()函数一次只能输入一个字符串。
2 总结
%d,遇到数字,'+','-'以外的字符结束,可跳过空格

%f,,%lf:遇到数字, '.', 'e','+','-'之外的字符结束,可跳过空格

%s,从第一个非空格字符起直到下一个空格结束.

%c,遇到字符就赋值,不管是空格还是回车之类的.

假如程序中出现这样的代码,scanf("%d,%s,%c,%c").虽然程序是以 ', '作为分隔的,但%s是不认这个 ', '的,它只认空格,所以会出现变量不能正确赋值的情况,如果你将','去掉,但由于%c却遇到空格又不会跳过,所以也不会满足需要,通过上面的我们知道,%c遇到空格是不会跳过的,所以我采取下面这个方式来解决,在%c的前面加一个空格来处理,这样就可以解决上面的所有问题了,所以我们在使用%c时,要在前面加上一个空格,养成这种习惯可以省去不少麻烦,并且在使用%c之前最好还加上一句fflush(stdin);用来清除缓存.
3 gets()
   功能:从stdin流中读取字符串，直至接受到换行符或EOF时停止，并将读取的结果存放在str指针所指向的字符数组中。换行符不作为读取串的内容，读取的换行符被转换为null值，并由此来结束字符串。
   注意:本函数可以无限读取，不会判断上限，所以程序员应该确保str的空间足够大，以便在执行读操作时不发生溢出。
   实例：#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排序方法

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

一、对int类型数组排序

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类型数组排序（同int类型）

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类型数组排序（特别要注意）

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)；

四、对结构体一级排序

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

//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写

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

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

五、对结构体二级排序

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

//按照x从小到大排序，当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];

//按照结构体中字符串str的字典顺序排序

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函数，把除了1点外的所有点，旋转角度排序
{
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)) //如果在一条直线上，则把远的放在前面
return 1;
else return -1;
}

PS:

其中的qsort函数包含在的头文件里，strcmp包含在的头文件里

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

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

ivy-jie — Mon, 18 May 2009 09:26:00 GMT

你不应该在构造或析构期间调用虚函数，因为这样的调用不会如你想象那样工作，而且它们做的事情保证会让你很郁闷。假设你有一套模拟股票处理的类层次结构，例如，购入流程，出售流程等。对这样的处理来说可以核查是非常重要的，所以随时会创建一个 Transaction 对象，将这个创建记录在核查日志中是一个适当的要求。下面是一个看起来似乎合理的解决问题的方法：

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
...
};

　　考虑执行这行代码时会发生什么：

BuyTransaction b;

　　很明显 BuyTransaction 的构造函数会被调用，但是首先，Transaction 的构造函数必须先被调用，派生类对象中的基类部分先于派生类部分被构造。Transaction 的构造函数的最后一行调用虚函数 logTransaction，但是结果会让你大吃一惊，被调用的 logTransaction 版本是在 Transaction 中的那个，而不是 BuyTransaction 中的——即使被创建的对象类型是 BuyTransaction。基类构造期间，虚函数从来不会向下匹配（go down）到派生类。取而代之的是，那个对象的行为就好像它的类型是基类。非正式地讲，基类构造期间，虚函数禁止。这个表面上看起来匪夷所思的行为存在一个很好的理由。因为基类的构造函数在派生类构造函数之前执行，当基类构造函数运行时，派生类数据成员还没有被初始化。如果基类构造期间调用的虚函数向下匹配（go down）到派生类，派生类的函数理所当然会涉及到本地数据成员，但是那些数据成员还没有被初始化。这就会为未定义行为和悔之晚矣的调试噩梦开了一张通行证。调用涉及到一个对象还没有被初始化的部分自然是危险的，所以 C++ 告诉你此路不通。
在实际上还有比这更多的更深层次的原理。在派生类对象的基类构造期间，对象的类型是那个基类的。不仅虚函数会解析到基类，而且语言中用到运行时类型信息（runtime type information）的配件（例如，dynamic_cast和 typeid），也会将对象视为基类类型。在我们的例子中，当 Transaction 构造函数运行初始化 BuyTransaction 对象的基类部分时，对象的类型是 Transaction。C++ 的每一个配件将以如下眼光来看待它，并对它产生这样的感觉：对象的 BuyTransaction 特有的部分还没有被初始化，所以安全的对待它们的方法就是视若无睹。在派生类构造函数运行之前，一个对象不会成为一个派生类对象。

　　同样的原因也适用于析构过程。一旦派生类析构函数运行，这个对象的派生类数据成员就被视为未定义的值，所以 C++ 就将它们视为不再存在。在进入基类析构函数时，对象就成为一个基类对象，C++ 的所有配件——虚函数，dynamic_casts 等——都如此看待它。

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

虚函数实现机制

ivy-jie — Mon, 18 May 2009 01:26:00 GMT

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
1 虚函数表
虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

2 代码：
#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<<"虚函数表-第一个函数地址:"<< 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();
}
//结果
虚函数表地址:0x0012FF7C
虚函数表-第一个函数地址: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是指向某函数的指针
p是指向某函数的指针，该函数无输入参数，返回值的类型为void。左边圆括弧里星号后的就是指针变量名。有了指针变量便可以赋值，值的内容是署名匹配的函数名和返回类型。例如：

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

p的赋值可以不同，但一定要是函数的地址，并且署名和返回类型相同。

传递回调函数的地址给调用者

现在可以将p传递给另一个函数（调用者）- caller()，它将调用p指向的函数，而此函数名是未知的：

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

    如果赋了不同的值给p（不同函数地址），那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

调用规范

    到目前为止，我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中，可以在函数类型前加_cdecl，_stdcall或者_pascal来表示其调用规范（默认为_cdecl）。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

    将调用规范看成是函数类型的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参数，以int为返回值
__stdcall int callee(int);

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

// 在p中企图存储被调用函数地址的非法操作
__cdecl int(*p)(int) = callee; // 出错

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

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