午夜老司机精品,久久精品国产欧美激情,欧美视频一区二区三区在线观看

Datatype misalignment

心羽 — Tue, 26 Apr 2011 11:26:00 GMT

http://blog.csdn.net/lqk1985/archive/2008/10/23/3129976.aspx

对于��d��数据��时�Q�如�|�络或文�Ӟ��要特别注意�?/p>

比如

PBYTE pData;

//指向接收到的数据��?/p>

int * pi = pData + �q�次接收到数据流的大��?- 4�Q?/p>

//指向接收到数据流的最�?�?可能客户端发�q�来的这个数据流最�?位是int�Q�那样就是对齐好的了。也有可能不是int�?/p>

if *pi = 4561321 endparse data;//判断作�ؓ数据��的�l�束标志�Q�最�?位的前面可能是全是char的�?/p>

�׃��q�最�?位可能不是int�Q�那样就有可能不寚w��Q�这里就会出现Datatype misalignment错误。但是我们还是必��通过最�?位作为结束标志，而只有知道什么时候结束才能用int指针指向最�?位才不会出现寚w��错误。这样�Ş成了一个死循环�Q�难道没办法解决了么�Q?/p>

PBYTE pData;

PBYTE * pi = pData + �q�次接收到数据流的大��?- 4�Q?/p>

int i;

memcpy(&i, pi, 4);

if i = 4561321 endparse data;

�q�样��可以解决用int* pi指向未对齐的int错误了�?/p>

�q�一招对所有碰到Datatype misalignment的数据的讉K��应该都有效，��是把Datatype misalignment的数据用memcpy拯��到对齐的内存来访问�?/p>

1�Q�解析数据流时应该时��L��意。如果需要把一个数据流�Q�BUFFER�Q��{化成�l�构�q�行取��|��应该把�q�个�l�构定义为按字节存取.考虑如下�l�构�Q?/p>

struct a{

char a;
short b;
long c;
};
如果某个数据��中包含�q�样的结构，而且我们要直接将数据��的指针转化成该�l�构的指针，然后直接取结构成员的��|��我们��应该将�q�个�l�构定义成按字节讉K��Q�即��其夹在语句
#pragma pack(push,1)//设�ؓ1字节寚w��
...

#pragma pack(pop)//�q�原为原来的字节寚w��方式
之中。如果我们不�q�样做，�~�译器会��成员b的地址寚w��到short指针的地址�Q�即在a之后加上一个char�?位的成员�Q�将C寚w��到LONG�Q�即在B之后再加一个char成员。如此一来，成员B和成员C��得不到正确的��g��?/p>

pragma pack 只作用于�l�构的定义，而不是分配内存空间。把一个结构定义�ؓpack1后，�q�个�l�构在程序中��׃��直是1了�?/p>

上面�q�个例子是客��L��发�?个连�l�的数据不是发送结构体�Q�服务端接收�l�构体�?/p>

如果客户端也发送结构体�Q�服务端也接收结构体��׃��需要这样了。但是前提是双方的对齐方式一致。所以在客户端发送前也要�?pragma pack()一下，服务端也�?pragma pack()一下�?/p>

最好还是客��L��也单个数据发送，服务端也单个数据接收�?/p>

如果我们定义一个普通的�l�构用来存放一些数据，则不用定义成按字节存取，�~�译器会加上一些占位成员，但�ƈ不会影响�E�序的运行。从�q�个意义上讲�Q�在ARM中，��结构成员定义成CHAR和SHORT来节�U�内存是没有意义的�?/p>

一个典型的例子��文件系�l�的驱动�E�序�Q�文件是以一些已�l�定义好的结构存攑֜�存储介质上的�Q�它们被��d��C��个BUFFER中，而具体取某个文�g、目录结构时�Q�我们会��地址转化成结构而读取其中的倹{�?/p>

2�Q�访问外设时�?br>例如�Q�磁盘驱动通常�?6BIT的方式存取数据，��x��ơ存取两个字节，�q�样��p��求传�l�它的BUFFER是双字节寚w��的，驱动�E�序应该至上层传来的指针做出正确的处理以保证数据的正��性�?/p>

3.有时�Q�我们没有将数据��指针�{化�ؓ�l�构指针取��|��但如果我们读取的是双字节或者是四字节的数据�Q�同样需要注意对齐的问题�Q�例如，如果从一个BUFFER的偏�U?0处读取一个四字节��|��则实际得到的值是偏移8处的
地址上的DWORD倹{�?/p>

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/lqk1985/archive/2008/10/23/3129842.aspx

心羽 2011-04-26 19:26 发表评论

C++关键字：mutable、volatile、explicit以及__based

心羽 — Tue, 01 Mar 2011 09:32:00 GMT

摘要: mutable关键�? 关键字mutable是C�Q�＋中一个不常用的关键字,他只能用于类的非静态和非常量数据成员我们知道一个对象的状态由该对象的非静态数据成员决�?所以随着数据成员的改�?对像的状态也会随之发生变�? 如果一个类的成员函数被声明为const�c�d��,表示该函��C��会改变对象的状�?也就是该函数不会修改�cȝ��非静态数据成�?但是有些时候需要在该类函数中对... 阅读全文

心羽 2011-03-01 17:32 发表评论

�U�M��操作

心羽 — Sun, 23 Jan 2011 06:53:00 GMT

最�q�笔者一直在做JPEG的解码工作，发现用完全��用哈夫曼树进行解码比较费�Ӟ��而��用表�l�构存储�~�码和值的对应关系比较快捷�Q�但是也存在比较隑֤�理的地方�Q�比如解码工作通常是以位�ؓ单位的操作，�q�里必然会涉及到�U�M��操作�Q�而笔者之前对位的操作很少�Q�经验很�Ơ缺�Q�经�q�这�ơ历�l�终于发��C��一个自己曾�l�忽视的东西�Q�那��是C/C++中的�U�M��操作�Ҏ��出错的情��c�?/p>

1、什么样的数据类型可以直接移�?/strong>

char、short、int、long、unsigned char、unsigned short、unsigned int、unsigned long都可以进行移位操作，而double、float、bool、long double则不可以�q�行�U�M��操作�?/p>
2、有�W�号数据�c�d��的移位操�?/strong>

对于char、short、int、long�q�些有符��L��数据�c�d��Q?/p>

对负数进行左�U�：�W�号位始�l��ؓ1�Q�其他位左移
�Ҏ��数进行左�U�：所有位左移�Q�即 <<�Q�可能会变成负数
对负数进行右�U�：取绝对��|��然后右移�Q�再取相反数
�Ҏ��数进行右�U�：所有位右移�Q�即 >>

3、无�W�号数据�c�d��的移位操�?/strong>

对于unsigned char、unsigned short、unsigned int、unsigned long�q�些无符��h��据类型：

没有�Ҏ��要说明的�Q��?lt;< �?>> 操作�W�就OK�?/p>
�l�束�?/p>
8086 中存在逻辑�U�M��、算术移位，而C\C++中的�U�M��g��既不是逻辑�U�M��Q�也不是��术�U�M��?/p>
比如-1�Q�我们若对它右移1位，C的结果仍旧是-1�Q�事实上无论右移多少位始�l�是-1�Q�逻辑�U�M��得到的结果（8位表�C�）应该�?128�Q�所以这点要注意

例子�Q?br>1.��?13800138000 转�ؓ 91 68 31 08 10 83 00 F0 //91�? 68国家�?不够位长以F�?/strong>

unsigned char *tt = new unsigned char[12];
        strcpy((char*)tt,"13800138000");
      tt[11] = 0xFF;
        unsigned char *ss = new unsigned char[6];
        cout << (tt[11]<<4) << endl;
        memset(ss,0xFF,6);
        int k=0;
        for(int i=0; i<12; i=i+2)
        {
                ss[k++] = (tt[i+1]<<4)+(tt[i]&0x0F);
       }
2. ��?整�Ş 转�ؓ 3位字节型16�q�制�Q�如��?整型 888 转�ؓ 16�q�制 00 03 78(Debug下有效，Release下无�?
   char param[4] = {0};
   int iParamLen = 888;
    param[0] = iParamLen >> 16;
    param[1] = ((iParamLen >> 8) << 32) >> 32;
    param[2] = (iParamLen << 32) >> 32;

反之

    char param[4] = {0x00,0x03,0x78};
    int ii1 = 0;
    ii1 = param[0];
    ii1 =ii1 << 8;
    ii1 = ii1 | param[1];
    ii1 =ii1 << 8;
    ii1 = ii1 | param[2];

心羽 2011-01-23 14:53 发表评论

心羽 — Fri, 21 Jan 2011 06:04:00 GMT

�?font style="BACKGROUND-COLOR: #ffff00">做嵌入式软�g的设计中�Q�经�怼�遇到十六�q�制、BCD码与十进制之间的转换�Q�最�q�做M1卡的应用中，涉及了大量的十六�q�制、BCD码与十进制之间的转换。笔者通过对BCD码、十六进�?权的理解�Q�轻杄��实现了他们之间的互换�?/font>

#include
#include >

/////////////////////////////////////////////////////
//
//功能�Q�二�q�制取反
//
//输入�Q�const unsigned char *src 二进制数�?
//      int length                待�{换的二进制数据长�?
//
//输出�Q�unsigned char *dst        取反后的二进制数�?
//
//�q�回�Q?    success
//
//////////////////////////////////////////////////////
int convert(unsigned char *dst, const unsigned char *src, int length)
{
        int i;

        for(i=0; i        {
                dst[i] = src[i]^0xFF;
        }
        return 0;
}

//////////////////////////////////////////////////////////
//
//功能�Q�十六进制�{为十�q�制
//
//输入�Q�const unsigned char *hex         待�{换的十六�q�制数据
//      int length                       十六�q�制数据长度
//
//输出�Q?
//
//�q�回�Q�int rslt                        转换后的十进制数�?
//
//思�\�Q�十六进制每个字�W�位所表示的十�q�制数的范围�? ~255�Q�进制�ؓ256
//      左移8�?<<8)�{��h乘以256
//
/////////////////////////////////////////////////////////
unsigned long HextoDec(const unsigned char *hex, int length)
{
    int i;
    unsigned long rslt = 0;

    for(i=0; i    {
        rslt += (unsigned long)(hex[i])<<(8*(length-1-i));

    }

    return rslt;
}

/////////////////////////////////////////////////////////
//
//功能�Q�十�q�制转十六进�?
//
//输入�Q�int dec                     待�{换的十进制数�?
//      int length                  转换后的十六�q�制数据长度
//
//输出�Q�unsigned char *hex          转换后的十六�q�制数据
//
//�q�回�Q?    success
//
//思�\�Q�原理同十六�q�制转十�q�制
//////////////////////////////////////////////////////////
int DectoHex(int dec, unsigned char *hex, int length)
{
    int i;

    for(i=length-1; i>=0; i--)
    {
        hex[i] = (dec%256)&0xFF;
        dec /= 256;
    }

    return 0;
}

/////////////////////////////////////////////////////////
//
//功能�Q�求�?
//
//输入�Q�int base                    �q�制基数
//      int times                   权��?
//
//输出�Q?
//
//�q�回�Q�unsigned long               当前数据位的�?
//
//////////////////////////////////////////////////////////
unsigned long power(int base, int times)
{
    int i;
    unsigned long rslt = 1;

    for(i=0; i        rslt *= base;

    return rslt;
}

/////////////////////////////////////////////////////////
//
//功能�Q�BCD�?0�q�制
//
//输入�Q�const unsigned char *bcd     待�{换的BCD�?
//      int length                   BCD码数据长�?
//
//输出�Q?
//
//�q�回�Q�unsigned long               当前数据位的�?
//
//思�\�Q�压�~�BCD码一个字�W�所表示的十�q�制数据范围�? ~ 99,�q�制�?00
//      先求每个字符所表示的十�q�制��|��然后乘以�?
//////////////////////////////////////////////////////////
unsigned long BCDtoDec(const unsigned char *bcd, int length)
{
     int i, tmp;
     unsigned long dec = 0;

     for(i=0; i     {
        tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);
        dec += tmp * power(100, length-1-i);
     }

     return dec;
}

/////////////////////////////////////////////////////////
//
//功能�Q�十�q�制转BCD�?
//
//输入�Q�int Dec                      待�{换的十进制数�?
//      int length                   BCD码数据长�?
//
//输出�Q�unsigned char *Bcd           转换后的BCD�?
//
//�q�回�Q? success
//
//思�\�Q�原理同BCD码�{十进�?
//
//////////////////////////////////////////////////////////
int DectoBCD(int Dec, unsigned char *Bcd, int length)
{
     int i;
     int temp;

     for(i=length-1; i>=0; i--)
     {
         temp = Dec%100;
         Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
         Dec /= 100;
     }

     return 0;
}

int main()
{
    register int i;
    unsigned char tmp_bff[12] = "";

    //十六�q�制转十�q�制
    unsigned char HEX[4] = {0x34, 0xFE, 0x3E, 0xFF};
    unsigned long dec_hex = 0;

    dec_hex = HextoDec(HEX, 4);

    printf("dec_hex = %d\n", dec_hex);

    //十进制�{十六�q�制
    DectoHex(dec_hex, tmp_bff, 4);
    for(i=0; i<5; i++)
    {
        printf("tmp_bff[%d] = 0x%02X\n",i, tmp_bff[i]);
    }

    //BCD码�{十进�?
    unsigned long dec_bcd = 0;
    unsigned char BCD[4] = {0x98, 0x23, 0x45, 0x78};

    dec_bcd = BCDtoDec(BCD, 4);
    printf("dec_bcd = %d\n", dec_bcd);

    //十进制�{BCD�?
    DectoBCD(dec_bcd, tmp_bff, 4);
    for(i=0; i<5; i++)
    {
        printf("tmp_bff[%d] = 0x%02X\n", i, tmp_bff[i]);
    }

    getchar();
}

BCD

void BCDToChar(const unsigned char *src,unsigned int srcLen, unsigned char *dest)
{
    unsigned char temp[2] = {0};
    unsigned char temp2[1] = {0};
    for(int i=0; i<srcLen; i++)
    {
       temp2[0] = src[i];

       temp[0] = src[i]>>4;
       temp[0] = temp[0]&0x0F;
       temp[0] = temp[0]+0x30;

       temp[1] = temp2[0]&0x0F;
       temp[1] = temp[1]+0x30;

       dest[i*2] = temp[0];
       dest[i*2+1] = temp[1];
    }
}

心羽 2011-01-21 14:04 发表评论

Visual C++�~�程命名规则

心羽 — Mon, 17 Jan 2011 02:51:00 GMT
一、程序风��|��
    1、严格采用阶梯层�ơ组�l�程序代码：
    各层�ơ羃�q�的分格采用VC的缺省风��|��x��层次�~�进�?��|��括号位于下一行。要求相匚w��的大括号在同一列，对��行则要求再羃�q?根{��例如：
    2、提�C�Z��息字�W�串的位�|?/strong>
    在程序中需要给出的提示字符�Ԍ��Z��支持多种语言的开发，除了一些给调试用的临时信息外，其他所有的提示信息必须定义在资源中�?nbsp;
    3、对变量的定义，��量位于函数的开始位�|��?/strong>
二、命名规则：
    1、变量名的命名规�?/strong>
    ①、变量的命名规则要求�?#8220;匈牙利法�?#8221;。即开头字母用变量的类型，其余部分用变量的英文意思或其英文意思的�~�写,��量避免用中文的拼音,要求单词的第一个字母应大写�?nbsp;
    卻I��     变量�?变量�c�d��+变量的英文意思（或羃写）
    寚w��通用的变量，在定义时加入注释说明�Q�变量定义尽量可能放在函数的开始处�?nbsp;
    见下表：
    bool(BOOL)     用b开�?nbsp;    bIsParent
    byte(BYTE)     用by开�?nbsp;    byFlag
    short(int)     用n开�?nbsp;    nStepCount
    long(LONG)     用l开�?nbsp;    lSum
    char(CHAR)     用c开�?nbsp;    cCount
    float(FLOAT)     用f开�?nbsp;    fAvg
    double(DOUBLE)     用d开�?nbsp;    dDeta
    void(VOID)     用v开�?nbsp;    vVariant
    unsigned     int�Q�WORD�Q?nbsp;    用w开�?nbsp;    wCount
    unsigned     long(DWORD)     用dw开�?nbsp;    dwBroad
    HANDLE�Q�HINSTANCE�Q?nbsp;    用h开�?nbsp;    hHandle
    DWORD     用dw开�?nbsp;    dwWord
    LPCSTR(LPCTSTR)     用str开�?nbsp;    strString
    �?�l�尾的字�W�串     用sz开�?nbsp;    szFileName

    �Ҏ��l�出的变量类型要求提出�ƈ�l�出命名��l�技术委员会�?nbsp;

    ②、指针变量命名的基本原则为：
    对一重指针变量的基本原则为：
    “p”+变量�c�d��前缀+命名
    如一个float*型应该表�C�ZؓpfStat
    对多重指针变量的基本规则为：
    二重指针�Q?nbsp;    “pp”+变量�c�d��前缀+命名
    三重指针�Q?nbsp;    “ppp”+变量�c�d��前缀+命名
    ......
    ③、全局变量用g_开�?如一个全局的长型变量定义�ؓg_lFailCount,卻I��变量�?g_+变量�c�d��+变量的英文意思（或羃写）
    ④、静态变量用s_开�?如一个静态的指针变量定义�?span style="COLOR: #008000">s_plPerv_Inst,卻I��     变量�?s_+变量�c�d��+变量的英文意思（或羃写）
    ⑤、成员变量用m_开�?如一个长型成员变量定义�ؓm_lCount;卻I��变量�?m_+变量�c�d��+变量的英文意思（或羃写）
    ⑥、对枚�D�c�d��Q�enum�Q�中的变量，要求用枚丑֏�量或其羃写做前缀。�ƈ且要求用大写�?nbsp;
    如：enum     cmEMDAYS
    {
    EMDAYS_MONDAY;
    EMDAYS_TUESDAY;
    ……
    };
    ⑦、对struct、union、class变量的命名要求定义的�c�d��用大写。�ƈ要加上前�~��Q�其内部变量的命名规则与变量命名规则一致�?nbsp;
    �l�构一般用S开�?nbsp;
    如：struct     ScmNPoint
    {
    int     nX;//点的X位置
    int     nY;     //点的Y位置
    };
    联合体一般用U开�?nbsp;
    �?     union     UcmLPoint
    {
    long     lX;
    long     lY;
    }
    �c�M��般用C开�?nbsp;
    如：
    class     CcmFPoint
    {
    public:
    float     fPoint;
    };
    对一般的�l�构应该定义为类模板�Q��ؓ以后的扩展性考虑
    如：
    template
    class     CcmTVector3d
    {
    public:
    TYPE     x,y,z;
    };
    ⑧、对帔R��Q�包括错误的�~�码�Q�命名，要求帔R��名用大写�Q�常量名用英文表辑օ�意思�?nbsp;
    �?span style="COLOR: #008000">�Q?define     CM_FILE_NOT_FOUND     CMMAKEHR(0X20B)     其中CM表示�c�d��?nbsp;
    ⑨、对const     的变量要求在变量的命名规则前加入c_,卻I��c_+变量命名规则�Q�例如：
    const     char*     c_szFileName;
    2�?nbsp;    函数的命名规范：
    函数的命名应该尽量用英文表达出函数完成的功能。遵循动宄��构的命名法则�Q�函数名中动词在�?�q�在命名前加入函数的前缀�Q�函数名的长度不得少�?个字母�?nbsp;
    例如�Q?nbsp;
    long     cmGetDeviceCount(……);
    3、函数参数规范：
    ①�?nbsp;    参数名称的命名参照变量命名规范�?nbsp;
    ②�?nbsp;    ��Z��提高�E�序的运行效率，减少参数占用的堆栈，传递大�l�构的参敎ͼ�一律采用指针或引用方式传递�?nbsp;
    ③�?nbsp;    ��Z��便于其他�E�序员识别某个指针参数是入口参数�q�是出口参数�Q�同时便于编译器��查错误，应该在入口参数前加入const标志。如�Q?nbsp;
    ……cmCopyString(const     char     *     c_szSource,     char     *     szDest)
    4、引出函数规范：
    对于从动态库引出作�ؓ二次开发函数公开的函敎ͼ��Z��能与其他函数以及Windows的函数区分，采用�c�d��前缀+基本命名规则的方法命名。例如：在对动态库中引出的一个图象编辑的函数定义�?nbsp;    imgFunctionname(其中img为image�~�写)�?nbsp;
    现给��Z��U�库的命名前�~��Q?nbsp;
    ①�?nbsp;    寚w��用函数库，采用cm为前�~��?nbsp;
    ②�?nbsp;    对三�l�函数库�Q�采用vr为前�~��?nbsp;
    ③�?nbsp;    对图象函数库�Q�采用img为前�~��?/span>
    对宏定义�Q�结果代码用同样的前�~��?nbsp;
    5、文件名(包括动态库、组件、控件、工�E�文件等)的命名规范：
    文�g名的命名要求表达出文件的内容�Q�要求文件名的长度不得少�?个字母，严禁使用象file1,myfile之类的文件名�?nbsp;

三、注释规范：
    1、函数头的注�?/strong>
    对于函数�Q�应该从“功能”�Q?#8220;参数”�Q?#8220;�q�回�?#8221;�?#8220;主要思�\”�?#8220;调用�Ҏ��”�?#8220;日期”六个斚w��用如下格式注释：
    //�E�序说明开�?nbsp;
    //================================================================//
    //     功能�Q?nbsp;    从一个String     中删除另一个String�?nbsp;
    //     参数�Q?nbsp;    strByDelete,strToDelete
    //     �Q�入口）     strByDelete:     被删除的字符�Ԍ��原来的字�W�串�Q?nbsp;
    //     �Q�出口）     strToDelete:     要从上个字符串中删除的字�W�串�?nbsp;
    //     �q�回�Q?nbsp;    扑ֈ��q�删除返�?�Q�否则返�?。（对返回值有错误�~�码的要//     求列出错误编码）�?nbsp;
    //     主要思�\�Q�本��法主要采用循环比较的方法来从strByDelete中找�?nbsp;
    //     与strToDelete相匹配的字符�Ԍ��对多匚w��strByDelete
    //     中有多个strToDelete子串�Q�的情况没有处理。请参阅�Q?nbsp;
    //     书名......
    //     调用�Ҏ��Q?.....
    //     日期�Q��v始日期，如：2000/8/21.9:40--2000/8/23.21:45
    //================================================================//
    函数�?……)
    //�E�序说明�l�束
    ①�?nbsp;    对于某些函数�Q�其部分参数��Z��入��|��而部分参��Cؓ传出��|��所以对参数要详�l�说明该参数是入口参敎ͼ��q�是出口参数�Q�对于某些意义不明确的参数还要做详细说明�Q�例如：以角度作为参数时�Q�要说明该角度参数是以弧度（PI�Q?�q�是以度为单位）,�Ҏ��是入口又是出口的变量应该在入口和出口处同时标明。等�{��?nbsp;
    ②�?nbsp;    函数的注释应该放�|�在函数的头文�g中，在实现文件中的该函数的实现部分应该同时放�|�该注释�?nbsp;
    ③�?nbsp;    在注释中应该详细说明函数的主要实现思�\、特别要注明自己的一些想法，如果有必要则应该写明�Ҏ��法��生的来由。对一些模仿的函数应该注释上函数的出处�?nbsp;
    ④�?nbsp;    在注释中详细注明函数的适当调用�Ҏ��Q�对于返回值的处理�Ҏ��{�。在注释中要��调用时的危险斚w��Q�可能出错的地方�?nbsp;
    ⑤�?nbsp;    �Ҏ��期的注释要求记录从开始写函数到结束函数的��试之间的日期�?nbsp;
    ⑥�?nbsp;    对函数注释开始到函数命名之间应该有一�l�用来标识的�Ҏ��字符丌Ӏ?nbsp;
    如果��法比较复杂�Q�或��法中的变量定义与位�|�有养I��则要求对变量的定义进行图解。对难以理解的算法能图解��量图解�?nbsp;
    2、变量的注释�Q?/strong>
    对于变量的注释紧跟在变量的后面说明变量的作用。原则上对于每个变量应该注释�Q�但对于意义非常明显的变量，如：i,j�{��@环变量可以不注释�?nbsp;
    例如�Q?nbsp;    long     lLineCount     //�U�的�Ҏ��?nbsp;
    　3、文件的注释�Q?/strong>
    文�g应该在文件开头加入以下注释：
    /////////////////////////////////////////////////////////////////////
    //     工程:     文�g所在的��目名�?nbsp;
    //     作者：**�Q�修改者：**
    //     描述:说明文�g的功能�?nbsp;
    //     主要函数�Q?#8230;………
    //     版本:     说明文�g的版本，完成日期�?nbsp;
    //     修改:     说明�Ҏ��件的修改内容、修改原因以及修�Ҏ��期�?nbsp;
    //     参考文献：     ......
    /////////////////////////////////////////////////////////////////////
    ��Z��头文件被重复包含要求对头文�g�q�行定义如下:
    #ifndef     __FILENAME_H__
    #define     __FILENAME_H__
    其中FILENAME为头文�g的名字�?nbsp;
    　　　4、其他注释：
    在函数内我们不需要注释每一行语句。但必须在各功能模块的每一主要部分之前��d��块注释，注释每一�l�语句，在��@环、流�E�的各分支等�Q�尽可能多加以注释�?nbsp;
    其中的��@环、条件、选择�{�位�|�必��L��释�?nbsp;
    对于前后��序不能颠倒的情况�Q�徏议在注释中增加序受��?nbsp;
    例如�Q?nbsp;
    在其他顺序执行的�E�序中，每隔3�?行语句，必须加一个注释，注明�q�一�D�语句所�l�成的小模块的作用。对于自��q��一些比较独特的思想要求在注释中标明�?nbsp;

四、程序健壮性：
    1、函数的�q�回��D��范：
    对于函数的返回位�|�，��量保持单一性，即一个函数尽量做到只有一个返回位�|��?单入口单出口)�?nbsp;
    要求大家�l�一函数的返回��|��所有的函数的返回值都��以�~�码的方式返回�?nbsp;
    例如�~�码定义如下�Q?nbsp;
    #define     CM_POINT_IS_NULL     CMMAKEHR(0X200)
    :
    :
    ��函数实现如下�Q?nbsp;
    long     函数�?参数,……)
    {
    long     lResult;     //保持错误�?nbsp;
    lResult=CM_OK;
    //如果参数有错误则�q�回错误�?nbsp;
    if(参数==NULL)
    {
    lResult=CM_POINT_IS_NULL;
    goto     END;
    }
    ……
    END:
    return     lResult;
    }
    2、关于goto的应用：
    对goto语句的应用，我们要求��量��用goto语句。对一定要用的地方要求只能向后转移�?nbsp;
    3、资源变量的处理�Q�资源变量是指消耗系�l�资源的变量�Q�：
    对资源变量一定赋初倹{��分配的资源在用完后必须马上释放�Q��ƈ重新赋倹{�?nbsp;
    4、对复杂的条件判断，��Z��E�序的可��L��，应该��量使用括号�?nbsp;
    例：if(((szFileName!=NULL)&&(lCount>=0)))||(bIsRead==TRUE))

五、可�U�L��性：
    1、高质量的代码要求能够跨�q�_��Q�所以我们的代码应该考虑到对不同的��^台的支持�Q�特别是对windows98和windowsnt的支持�?nbsp;
    2、由于C语言的移植性比较好�Q�所以对��法函数要求用C代码�Q�不能用C++代码�?nbsp;
    3、对不同的硬件与软�g的函数要做不同的处理
匈牙利命名法

MFC、句柄、控件及�l�构的命名规�? Windows�c�d�� h��变量 MFC�c? ��h��变量
HWND hWnd�Q? CWnd* pWnd�Q?
HDLG hDlg�Q? CDialog* pDlg�Q?
HDC hDC�Q? CDC* pDC�Q?
HGDIOBJ hGdiObj�Q? CGdiObject* pGdiObj�Q?
HPEN hPen�Q? CPen* pPen�Q?
HBRUSH hBrush�Q? CBrush* pBrush�Q?
HFONT hFont�Q? CFont* pFont�Q?
HBITMAP hBitmap�Q? CBitmap* pBitmap�Q?
HPALETTE hPaltte�Q? CPalette* pPalette�Q?
HRGN hRgn�Q? CRgn* pRgn�Q?
HMENU hMenu�Q? CMenu* pMenu�Q?
HWND hCtl�Q? CState* pState�Q?
HWND hCtl�Q? CButton* pButton�Q?
HWND hCtl�Q? CEdit* pEdit�Q?
HWND hCtl�Q? CListBox* pListBox�Q?
HWND hCtl�Q? CComboBox* pComboBox�Q?
HWND hCtl�Q? CScrollBar* pScrollBar�Q?
HSZ hszStr�Q? CString pStr�Q?
POINT pt�Q? CPoint pt�Q?
SIZE size�Q? CSize size�Q?
RECT rect�Q? CRect rect�Q?

一般前�~�命名规范前缀 �c�d�� 实例
C �c�L��l�构 CDocument�Q�CPrintInfo
m_ 成员变量 m_pDoc�Q�m_nCustomers

变量命名规范前缀 �c�d�� 描述实例
ch char 8位字�W? chGrade
ch TCHAR 如果_UNICODE定义�Q�则�?6位字�W? chName
b BOOL 布尔�? bEnable
n int 整型�Q�其大小依赖于操作系�l�） nLength
n UINT 无符号��|��其大��依赖于操作�pȝ��Q? nHeight
w WORD 16位无�W�号�? wPos
l LONG 32位有�W�号整型 lOffset
dw DWORD 32位无�W�号整型 dwRange
p * 指针 pDoc
lp FAR* �q�指�? lpszName
lpsz LPSTR 32位字�W�串指针 lpszName
lpsz LPCSTR 32位常量字�W�串指针 lpszName
lpsz LPCTSTR 如果_UNICODE定义�Q�则�?2位常量字�W�串指针 lpszName
h handle Windows对象句柄 hWnd
lpfn callback 指向CALLBACK函数的远指针

应用�E�序�W�号命名规范前缀 �W�号�c�d�� 实例范围
IDR_ 不同�c�d��的多个资源共享标�? IDR_MAIINFRAME 1�?x6FFF
IDD_ 对话框资�? IDD_SPELL_CHECK 1�?x6FFF
HIDD_ 对话框资源的Help上下�? HIDD_SPELL_CHECK 0x20001�?x26FF
IDB_ 位图资源 IDB_COMPANY_LOGO 1�?x6FFF
IDC_ 光标资源 IDC_PENCIL 1�?x6FFF
IDI_ 图标资源 IDI_NOTEPAD 1�?x6FFF
ID_ 来自菜单��Ҏ��工具栏的命��o ID_TOOLS_SPELLING 0x8000�?xDFFF
HID_ 命��oHelp上下�? HID_TOOLS_SPELLING 0x18000�?x1DFFF
IDP_ 消息框提�C? IDP_INVALID_PARTNO 8�?xDEEF
HIDP_ 消息框Help上下�? HIDP_INVALID_PARTNO 0x30008�?x3DEFF
IDS_ 串资�? IDS_COPYRIGHT 1�?x7EEF
IDC_ 对话框内的控�? IDC_RECALC 8�?xDEEF

Microsoft MFC宏命名规�? 名称 �c�d��
_AFXDLL 唯一的动态连接库�Q�Dynamic Link Library�Q�DLL�Q�版�?
_ALPHA 仅编译DEC Alpha处理�?
_DEBUG 包括诊断的调试版�?
_MBCS �~�译多字节字�W�集
_UNICODE 在一个应用程序中打开Unicode
AFXAPI MFC提供的函�?
CALLBACK 通过指针回调的函�?

库标识符命名�? 标识�W? 值和含义
u ANSI�Q�N�Q�或Unicode�Q�U�Q?
d 调试或发行：D = 调试�Q�忽略标识符为发行�?

静态库版本命名规范 �? 描述
NAFXCWD.LIB 调试版本�Q�MFC静态连接库
NAFXCW.LIB 发行版本�Q�MFC静态连接库
UAFXCWD.LIB 调试版本�Q�具有Unicode支持的MFC静态连接库

UAFXCW.LIB 发行版本�Q�具有Unicode支持的MFC静态连接库

动态连接库命名规范名称 �c�d��
_AFXDLL 唯一的动态连接库�Q�DLL�Q�版�?

WINAPI Windows所提供的函�?

Windows.h中新的命名规�? �c�d�� 定义描述
WINAPI 使用在API声明中的FAR PASCAL位置�Q�如果正在编写一个具有导出API人口点的DLL�Q�则可以在自��q��API中��用该�c�d��
CALLBACK 使用在应用程序回叫例�E�，如窗口和对话框过�E�中的FAR PASCAL的位�|?
LPCSTR 与LPSTR相同�Q�只是LPCSTR用于只读串指针，其定义类��|��const char FAR*�Q?
UINT 可移植的无符��h��型类型，其大��由��L��环境军_��Q�对于Windows NT和Windows 9x�?2位）�Q�它是unsigned int的同义词
LRESULT �H�口�E�序�q�回值的�c�d��
LPARAM 声明lParam所使用的类型，lParam是窗口程序的�W�四个参�?
WPARAM 声明wParam所使用的类型，wParam是窗口程序的�W�三个参�?
LPVOID 一般指针类型，与（void *�Q�相同，可以用来代替LPSTR

心羽 2011-01-17 10:51 发表评论

#ifdef __cplusplus 学习

心羽 — Tue, 21 Dec 2010 01:48:00 GMT

时常在cpp的代码之中看到这��L��代码:

#ifdef __cplusplus

extern "C" {

#endif

//一�D�代�?/p>
#ifdef __cplusplus

}

#endif

　　�q�样的代码到底是什么意思呢�Q�首先，__cplusplus是cpp中的自定义宏�Q�那么定义了�q�个宏的话表�C��是一�D�cpp的代码，也就是说�Q�上面的代码的含义是:如果�q�是一�D�cpp的代码，那么加入extern "C"{和}处理其中的代�?/span>�?/p>
　　要明白�ؓ何��用extern "C"�Q�还得从cpp中对函数的重载处理开始说赗��在c++中，��Z��支持重蝲机制�Q�在�~�译生成的汇�~�码中，要对函数的名字进行一些处理，加入比如函数的返回类型等�{?而在C中，只是��单的函数名字而已�Q�不会加入其他的信息.也就是说:C++和C对��生的函数名字的处理是不一��L��.

　　比如下面的一�D늮�单的函数�Q�我们看看加入和不加入extern "C"产生的汇�~�代码都有哪些变�?

int f(void)

{

return 1;

}

　　在加入extern "C"的时候��生的汇编代码�?

.file "test.cxx"

.text

.align 2

.globl _f

.def _f; .scl 2; .type 32; .endef

_f:

pushl %ebp

movl %esp�Q?%ebp

movl $1�Q?%eax

popl %ebp

ret

　　但是不加入了extern "C"之后

.file "test.cxx"

.text

.align 2

.globl __Z1fv

.def __Z1fv; .scl 2; .type 32; .endef

__Z1fv:

pushl %ebp

movl %esp�Q?%ebp

movl $1�Q?%eax

popl %ebp

ret

　　两段汇编代码同样都是使用gcc -S命��o产生的，所有的地方都是一��L��Q�唯独是产生的函数名�Q�一个是_f�Q�一个是__Z1fv�?/p>
　　明白了加入与不加入extern "C"之后对函数名�U�C�生的影响�Q�我们��l�我们的讨论:��Z��么需要��用extern "C"呢？C++之父在设计C++之时�Q�考虑到当时已�l�存在了大量的C代码�Q��ؓ了支持原来的C代码和已�l�写好C库，需要在C++中尽可能的支持C�Q�而extern "C"��是其中的一个策略�?/p>
　　试想�q�样的情�?一个库文�g已经用C写好了而且�q�行得很良好�Q�这个时候我们需要��用这个库文�g�Q�但是我们需要��用C++来写�q�个新的代码。如果这个代码��用的是C++的方式链接这个C库文件的话，那么��׃��出现链接错误.我们来看一�D�代�?首先�Q�我们��用C的处理方式来写一个函敎ͼ�也就是说假设�q�个函数当时是用C写成�?

//f1.c

extern "C"

{

void f1()

{

return;

}

}

　　�~�译命��o�?gcc -c f1.c -o f1.o 产生了一个叫f1.o的库文�g。再写一�D�代码调用这个f1函数:

// test.cxx

//�q�个extern表示f1函数在别的地方定义，�q�样可以通过

//�~�译�Q�但是链接的时候还是需�?/p>
//链接上原来的库文�?

extern void f1();

int main()

{

f1();

return 0;

}

　　通过gcc -c test.cxx -o test.o 产生一个叫test.o的文件。然后，我们使用gcc test.o f1.o来链接两个文�Ӟ��可是出错了，错误的提�C�是:

test.o(.text + 0x1f):test.cxx: undefine reference to 'f1()'

　　也就是说�Q�在�~�译test.cxx的时候编译器是��用C++的方式来处理f1()函数的，但是实际上链接的库文件却是用C的方式来处理函数的，所以就会出现链接过不去的错�?因�ؓ链接器找不到函数�?/p>
　　因此�Q?span style="COLOR: #ff0000">��Z��在C++代码中调用用C写成的库文�g�Q�就需要用extern "C"来告诉编译器:�q�是一个用C写成的库文�g�Q�请用C的方式来链接它们�?/span>

　　比如�Q�现在我们有了一个C库文�Ӟ��它的头文件是f.h�Q��生的lib文�g是f.lib�Q�那么我们如果要在C++中��用这个库文�g�Q�我们需要这样写:

extern "C"

{

#include "f.h"

}

　　回到上面的问题，如果要改正链接错误，我们需要这样子改写test.cxx:

extern "C"

{

extern void f1();

}

int main()

{

f1();

return 0;

}

　　重新�~�译�q�且链接��可以过��M��.

�ȝ��

C和C++对函数的处理方式是不同的.extern "C"是��C++能够调用C写作的库文�g的一个手�D�，如果要对�~�译器提�C�Z��用C的方式来处理函数的话�Q�那么就要��用extern "C"来说�?/span>�?/p>
1.引言

C++语言的创建初��h��“a better C”�Q�但是这�q�不意味着C++中类似C语言的全局变量和函数所采用的编译和�q�接方式与C语言完全相同。作��Z��U�欲与C兼容的语�a��Q�C++保留了一部分�q�程式语�a�的特点（被世人称�?#8220;不彻底地面向对象”�Q�，因而它可以定义不属于�Q何类的全局变量和函数。但是，C++毕竟是一�U�面向对象的�E�序设计语言�Q��ؓ了支持函数的重蝲�Q�C++对全局函数的处理方式与C有明昄��不同�?/p>
2.从标准头文�g说�v

某企业曾�l�给出如下的一道面试题�Q?/p>
面试�?/p>
��Z��么标准头文�g都有�c�M��以下的结构？

    #ifndef __INCvxWorksh

    #define __INCvxWorksh

    #ifdef __cplusplus

    extern "C" {

    #endif

    /*...*/

    #ifdef __cplusplus

    }

    #endif

    #endif /* __INCvxWorksh */

分析

昄��Q�头文�g中的�~�译�?#8220;#ifndef __INCvxWorksh�?define __INCvxWorksh�?endif” 的作用是防止该头文�g被重复引�?/span>�?/p>
那么

    #ifdef __cplusplus

    extern "C" {

    #endif

   #ifdef __cplusplus

    }

    #endif

的作用又是什么呢�Q�我们将在下文一一道来�?/p>
3.深层揭密extern "C"

extern "C" 包含双重含义�Q�从字面上即可得刎ͼ�首先�Q�被它修饰的目标�?#8220;extern”的；其次�Q�被它修饰的目标�?#8220;C”的。让我们来详�l�解读这两重含义�?/p>
�Q?�Q?nbsp;       被extern "C"限定的函数或变量是extern�c�d��?/span>�Q?/p>
extern是C/C++语言中表明函数和全局变量作用范围�Q�可见性）的关键字�Q�该关键字告诉编译器�Q�其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句�Q?/p>
extern int a;

仅仅是一个变量的声明�Q�其�q�不是在定义变量a�Q��ƈ未�ؓa分配内存�I�间。变量a在所有模块中作�ؓ一�U�全局变量只能被定义一�ơ，否则会出现连接错误�?/p>
通常�Q�在模块的头文�g中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B�Ʋ引用该模块A中定义的全局变量�?函数时只需包含模块A的头文�g卛_��。这��P��模块B中调用模块A中的函数�Ӟ��在编译阶�D�，模块B虽然找不到该函数�Q�但是�ƈ不会报错�Q�它会在�q�接阶段中从模块 A�~�译生成的目标代码中扑ֈ�此函数�?/p>
与extern对应的关键字是static�Q�被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块��用时�Q�其不可能被extern “C”修饰�?/p>
�Q?�Q?nbsp;       被extern "C"修饰的变量和函数是按照C语言方式�~�译和连接的�Q?/p>
未加extern “C”声明时的�~�译方式

首先看看C++中对�c�M��C的函数是怎样�~�译的�?/p>
作�ؓ一�U�面向对象的语言�Q�C++支持函数重蝲�Q�而过�E�式语言C则不支持。函数被C++�~�译后在�W�号库中的名字与C语言的不同。例如，假设某个函数的原型�ؓ�Q?/p>
void foo( int x, int y );

该函数被C�~�译器编译后在符号库中的名字�?span style="COLOR: #008000">_foo�Q��?span style="COLOR: #008000">C++�~�译器则会��生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机�Ӟ��生成的新名字�U�Cؓ“mangled name”�Q�。_foo_int_int�q�样的名字包含了函数名、函数参数数量及�c�d��信息�Q�C++��是靠这�U�机制来实现函数重蝲的。例如，在C++中，�?数void foo( int x, int y )与void foo( int x, float y )�~�译生成的符��h��不相同的�Q�后者�ؓ_foo_int_float�?/p>
同样圎ͼ�C++中的变量除支持局部变量外�Q�还支持�c�L��员变量和全局变量。用��h��~�写�E�序的类成员变量可能与全局变量同名�Q�我们以"."来区分。而本质上�Q�编译器在进行编译时�Q�与函数的处理相��|��也�ؓ�c�M��的变量取了一个独一无二的名字，�q�个名字与用��L��序中同名的全局变量名字不同�?/p>
未加extern "C"声明时的�q�接方式�Q?/span>

假设在C++中，模块A的头文�g如下�Q?/p>
// 模块A头文件　moduleA.h

#ifndef MODULE_A_H

        #define MODULE_A_H

     int foo( int x, int y );

#endif

在模块B中引用该函数�Q?/p>
// 模块B实现文�g　moduleB.cpp

�Q�i nclude "moduleA.h"

foo(2,3);

实际上，在连接阶�D�，�q�接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int�q�样的符��P��

加extern "C"声明后的�~�译和连接方式：

加extern "C"声明后，模块A的头文�g变�ؓ�Q?/p>
// 模块A头文件　moduleA.h

#ifndef MODULE_A_H

        #define MODULE_A_H

     extern "C" int foo( int x, int y );

#endif

在模块B的实现文件中仍然调用foo( 2,3 )�Q�其�l�果是：

�Q?�Q�模块A�~�译生成foo的目标代码时�Q�没有对其名字进行特�D�处理，采用了C语言的方式；

�Q?�Q�连接器在�ؓ模块B的目标代码寻找foo(2,3)调用�Ӟ��L��的是未经修改的符号名_foo�?/p>
如果在模块A中函数声明了foo为extern "C"�c�d��Q�而模块B中包含的是extern int foo( int x, int y ) �Q�则模块B找不到模块A中的函数�Q�反之亦然�?/p>
所以，可以用一句话概括extern “C”�q�个声明的真实目的（��M��语言中的��M��语法�Ҏ��的诞生都不是随意而�ؓ的，来源于真实世界的需求驱动。我们在思考问题时�Q�不能只停留在这个语�a�是怎么做的�Q�还要问一问它��Z��么要�q�么做，动机是什么，�q�样我们可以更深入地理解许多问题�Q�：

实现C++与C及其它语�a�的�؜合编�E��?/p>
明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的��用技巧�?/p>
4.extern "C"的惯用法

�Q?�Q�在C++中引用C语言中的函数和变量，在包含C语言头文�Ӟ��假设为cExample.h�Q�时�Q�需�q�行下列处理�Q?/p>
extern "C"

{

�Q�i nclude "cExample.h"

}

而在C语言的头文�g中，对其外部函数只能指定为extern�c�d��Q�C语言中不支持extern "C"声明�Q�在.c文�g中包含了extern "C"时会出现�~�译语法错误�?/p>
�W�者编写的C++引用C函数例子工程中包含的三个文�g的源代码如下�Q?/p>
/* c语言头文�Ӟ��cExample.h */

#ifndef C_EXAMPLE_H

#define C_EXAMPLE_H

extern int add(int x,int y);

#endif

/* c语言实现文�g�Q�cExample.c */

�Q�i nclude "cExample.h"

int add( int x, int y )

{

        return x + y;

}

// c++实现文�g�Q�调用add�Q�cppFile.cpp

extern "C"

{

�Q�i nclude "cExample.h"

}

int main(int argc, char* argv[])

{

        add(2,3);

        return 0;

}

如果C++调用一个C语言�~�写�?DLL�Ӟ��当包�?DLL的头文�g或声明接口函数时�Q�应加extern "C" {　}�?/p>
�Q?�Q�在C中引用C++语言中的函数和变量时�Q�C++的头文�g需��d��extern "C"�Q�但是在C语言中不能直接引用声明了extern "C"的该头文�Ӟ��应该仅将C文�g中将C++中定义的extern "C"函数声明为extern�c�d��?span class=Apple-style-span style="WORD-SPACING: 0px; FONT: medium Simsun; TEXT-TRANSFORM: none; COLOR: #000000; TEXT-INDENT: 0px; WHITE-SPACE: normal; LETTER-SPACING: normal; BORDER-COLLAPSE: separate; orphans: 2; widows: 2">
�W�者编写的C引用C++函数例子工程中包含的三个文�g的源代码如下�Q?/p>
//C++头文�?cppExample.h

#ifndef CPP_EXAMPLE_H

#define CPP_EXAMPLE_H

extern "C" int add( int x, int y );

#endif

//C++实现文�g cppExample.cpp

�Q�i nclude "cppExample.h"

int add( int x, int y )

{

        return x + y;

}

/* C实现文�g cFile.c

/* �q�样会编译出错：�Q�i nclude "cExample.h" */

extern int add( int x, int y );

int main( int argc, char* argv[] )

{

        add( 2, 3 );

        return 0;

}

心羽 2010-12-21 09:48 发表评论

心羽 — Fri, 17 Dec 2010 05:59:00 GMT

问题引入�Q?br>在实习过�E�中发现了一个以前一直默认的错误�Q�同样char *c = "abc"和char c[]="abc",前者改变其�?/span>

容程序是会崩溃的�Q�而后者完全正��?br>�E�序演示�Q?br>��试环境Devc++
代码
�q�行�l�果
2293628 4199056 abc
2293624 2293624 abc
2293620 4199056 abc

#include
using namespace std;

main()
{
char *c1 = "abc";
char c2[] = "abc";
char *c3 = ( char* )malloc(3);
c3 = "abc";
printf("%d %d %s\n",&c1,c1,c1);
printf("%d %d %s\n",&c2,c2,c2);
printf("%d %d %s\n",&c3,c3,c3);
getchar();
}

参考资料：
首先要搞清楚�~�译�E�序占用的内存的分区形式�Q?br>一、预备知�?�E�序的内存分�?br>一个由c/C++�~�译的程序占用的内存分�ؓ以下几个部分
1、栈区（stack�Q?��q��译器自动分配释放�Q�存攑և�数的参数��|��局部变量的值等。其操作方式�c�M��?/span>

数据�l�构中的栈�?br>2、堆区（heap�Q?一般由�E�序员分配释放，若程序员不释放，�E�序�l�束时可能由OS回收。注意它与数�?/span>

�l�构中的堆是两回事，分配方式倒是�c�M��于链表，呵呵�?br>3、全局区（静态区�Q�（static�Q?全局变量和静态变量的存储是放在一块的�Q�初始化的全局变量和静�?/span>

变量在一块区域，未初始化的全局变量和未初始化的静态变量在盔R��的另一块区域。程序结束后��q��l?/span>

释放�?br>4、文字常量区-帔R��字符串就是放在这里的。程序结束后��q��l�释放�?br>5、程序代码区
�q�是一个前辈写的，非常详细
//main.cpp
int a=0; //全局初始化区
char *p1; //全局未初始化�?br>main()
{
int b;�?br>char s[]="abc"; //�?br>char *p2; //�?br>char *p3="123456"; //123456\0在常量区�Q�p3在栈上�?br>static int c=0�Q?//全局�Q�静态）初始化区
p1 = (char*)malloc(10);
p2 = (char*)malloc(20); //分配得来�?0�?0字节的区域就在堆区�?br>strcpy(p1,"123456"); //123456\0攑֜�帔R��区，�~�译器可能会��它与p3所�?123456"优化成一�?/span>地方�?br>}
二、堆和栈的理论知�?br>2.1甌��方式
stack:
��q��l�自动分配。例如，声明在函��C��一个局部变量int b;�pȝ��自动在栈中�ؓb开辟空�?br>heap:
需要程序员自己甌��Q��ƈ指明大小�Q�在c中malloc函数
如p1=(char*)malloc(10);
在C++中用new�q�算�W?br>如p2=(char*)malloc(10);
但是注意p1、p2本��n是在栈中的�?br>2.2
甌��后系�l�的响应
栈：只要栈的剩余�I�间大于所甌��I�间�Q�系�l�将为程序提供内存，否则��报异常提示栈溢出�?br>堆：首先应该知道操作�pȝ��有一个记录空闲内存地址的链表，当系�l�收到程序的甌��Ӟ��
会遍历该链表�Q�寻扄��一个空间大于所甌��I�间的堆�l�点�Q�然后将该结点从�I�闲�l�点链表中删除，�q�将

该结点的�I�间分配�l�程序，另外�Q�对于大多数�pȝ��Q�会在这块内存空间中的首地址处记录本�ơ分配的�?/span>

��，�q�样�Q�代码中的delete语句才能正确的释放本内存�I�间。另外，�׃��扑ֈ�的堆�l�点的大��不一定正

好等于申��L��大小�Q�系�l�会自动的将多余的那部分重新攑օ��I�闲链表中�?br>2.3甌��大小的限�?br>栈：在Windows�?栈是向低地址扩展的数据结构，是一块连�l�的内存的区域。这句话的意思是栈顶的地

址和栈的最大容量是�pȝ��预先规定好的�Q�在WINDOWS下，栈的大小�?M�Q�也有的说是1M�Q��M��是一个编�?/span>

时就��定的常敎ͼ��Q�如果申��L��I�间��过栈的剩余�I�间�Ӟ��提�C�overflow。因此，能从栈获得的�I�间

较小�?br>堆：堆是向高地址扩展的数据结构，是不�q�箋的内存区域。这是由于系�l�是用链表来存储的空闲内存地

址的，自然是不�q�箋的，而链表的遍历方向是由低地址向高地址。堆的大��受限于计算机系�l�中有效�?/span>

虚拟内存。由此可见，堆获得的�I�间比较灉|��Q�也比较大�?br>2.4甌��效率的比较：
�?��q��l�自动分配，速度较快。但�E�序员是无法控制的�?br>�?是由new分配的内存，一般速度比较慢，而且�Ҏ��产生内存��片,不过用�v来最方便.
另外�Q�在WINDOWS下，最好的方式是用Virtual Alloc分配内存�Q�他不是在堆�Q�也不是在栈,而是直接在进

�E�的地址�I�间中保留一块内存，虽然用�v来最不方�ѝ��但是速度快，也最灉|��?br>2.5堆和栈中的存储内�?br>栈：在函数调用时�Q�第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句�Q�的

地址�Q�然后是函数的各个参敎ͼ�在大多数的C�~�译器中�Q�参数是由右往左入栈的�Q�然后是函数中的局部变

量。注意静态变量是不入栈的�?br>当本�ơ函数调用结束后�Q�局部变量先出栈�Q�然后是参数�Q�最后栈��指针指向最开始存的地址�Q�也��是�?/span>

函数中的下一条指令，�E�序��p��点��l�运行�?br>堆：一般是在堆的头部用一个字节存攑֠�的大��。堆中的具体内容��q��序员安排�?br>2.6存取效率的比�?br>char s1[]="aaaaaaaaaaaaaaa";
char *s2="bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在�q�行时刻赋值的�Q?br>而bbbbbbbbbbb是在�~�译时就��定的；
但是�Q�在以后的存取中�Q�在栈上的数�l�比指针所指向的字�W�串(例如�?快�?br>比如�Q?br>#include
voidmain()
{
char a=1;
char c[]="1234567890";
char *p="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇�~�代�?br>10:a=c[1];
004010678A4DF1movcl,byteptr[ebp-0Fh]
0040106A884DFCmovbyteptr[ebp-4],cl
11:a=p[1];
0040106D8B55ECmovedx,dwordptr[ebp-14h]
004010708A4201moval,byteptr[edx+1]
004010738845FCmovbyteptr[ebp-4],al
�W�一�U�在��d��时直接就把字�W�串中的元素��d��寄存器cl中，而第二种则要先把指针��D��到edx中，在根�?/span>

edx��d��字符�Q�显然慢了�?br>2.7��结�Q?br>堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜�Q�发出申��P��、付钱、和吃（使用�Q�，吃饱了就赎ͼ�不必理会

切菜、洗菜等准备工作和洗��、刷锅等扫尾工作�Q�他的好处是快捷�Q�但是自由度��?br>使用堆就象是自己动手做喜�Ƣ吃的菜��_��比较�ȝ��Q�但是比较符合自��q��口味�Q�而且自由度大�?/span>

自我�ȝ��Q?br>char *c1 = "abc";实际上先是在文字帔R��区分配了一块内存放"abc",然后在栈上分配一地址�l�c1�q�指�?/span>

�q�块地址�Q�然后改变常�?abc"自然会崩�?/span>

然而char c2[] = "abc",实际上abc分配内存的地方和上者�ƈ不一��P��可以�?br>4199056
2293624 看出�Q�完全是两块地方�Q�推�?199056处于帔R��区，�?293624处于栈区

2293628
2293624
2293620 �q�段输出看出三个指针分配的区域�ؓ栈区�Q�而且是从高地址��C��地址

2293620 4199056 abc 看出�~�译器将c3优化指向帔R��区的"abc"

�l�箋思考：
代码�Q?br>
输出�Q?br>2293628 4199056 abc
2293624 2293624 abc
2293620 4012976 gbc
写成注释那样�Q�后面改动就会崩�?br>可见strcpy(c3,"abc");abc是另一块地方分配的�Q�而且可以改变�Q�和上面的参考文档说法有些不一定，

#include
using namespace std;

main()
{
char *c1 = "abc";
char c2[] = "abc";
char *c3 = ( char* )malloc(3);
// *c3 = "abc" //error
strcpy(c3,"abc");
c3[0] = 'g';
printf("%d %d %s\n",&c1,c1,c1);
printf("%d %d %s\n",&c2,c2,c2);
printf("%d %d %s\n",&c3,c3,c3);
getchar();
}

心羽 2010-12-17 13:59 发表评论

EVC�U�L��到VC�ȝ��

心羽 — Sat, 20 Nov 2010 02:42:00 GMT
1.Unicode问题,在Project Settings�?C/C++卡片,里面有Preprocessor definitions里面�?_UNICODE,UNICODE
2.link -->output Entry-point symbol:wWinMainCRTStartup (支持双字�?
3.资源可以直接拯��?用VC打开eVC的资源文�?rc),然后eVC的资源就会出现VC
在右�?用鼠标拖到VC的资源中��可�?
4.其他��是一些细节问题了.可以用宏判断,是不是eVC的程�?如果是怎么处理,不是的话,��q��VC的处理方�?br>#ifdef _WIN32_WCE
#endif

心羽 2010-11-20 10:42 发表评论

基本数据�c�d��Q�字�W�型�Q�上�Q?

心羽 — Tue, 09 Nov 2010 13:23:00 GMT
     摘要: 1. 字符型（char�Q�简�?         字符型（char�Q�用于储存字�W�（character�Q�，如英文字母或标点。严格来��_��char 其实也是整数�c�d��Q�integer type�Q�，因�ؓ char �c�d��储存的实际上是整敎ͼ�而不是字�W�。计��机使用特定的整数编码来表示特定的字�W�。美国普遍��用的�~�码�?ASCII�Q?..  阅读全文

心羽 2010-11-09 21:23 发表评论

_cdecl,_fastcall和_stdcall的区�?

心羽 — Sun, 17 Oct 2010 11:37:00 GMT

C++ Calling Convention调用�U�定�Q?/span>
__cdecl __fastcall�?/span> __stdcall�Q�三者都是调用约�?/span>(Calling convention)�Q�它军_��以下内容�Q?/span>

1)函数参数的压栈顺序，2)��p��用者还是被调用者把参数弹出栈，3)以及产生函数修饰名的�Ҏ��?/span>

1�?/span>__stdcall调用�U�定�Q�函数的参数自右向左通过栈传递，被调用的函数在返回前清理传送参数的内存栈，

2�?/span>_cdecl�?/span>C�?/span>C�Q�＋�E�序的缺省调用方式。每一个调用它的函数都包含清空堆栈的代码，所以��生的可执行文件大��会比调�?/span>_stdcall函数的大。函数采用从叛_��左的压栈方式。注意：对于可变参数的成员函敎ͼ�始终使用__cdecl的�{换方式�?/span>

3�?/span>__fastcall调用�U�定�Q�它是通过寄存器来传送参数的�Q�实际上�Q�它�?/span>ECX�?/span>EDX传送前两个双字�Q?/span>DWORD�Q�或更小的参敎ͼ�剩下的参��C��旧自叛_��左压栈传送，被调用的函数在返回前清理传送参数的内存栈）�?/span>

4�?/span>thiscall仅仅应用�?/span>"C++"成员函数�?/span>this指针存放�?/span>CX寄存器，参数从右到左压�?/span>thiscall不是关键词，因此不能被程序员指定�?/span>

5�?/span>naked call采用1-4的调用约定时�Q�如果必要的话，�q�入函数时编译器会��生代码来保存ESI�Q?/span>EDI�Q?/span>EBX�Q?/span>EBP寄存器，退出函数时则��生代码恢复这些寄存器的内宏V�?/span>naked call不��生这��L��代码�?/span>naked call不是�c�d��修饰�W�，故必��d��_declspec共同使用�?/span>

调用�U�定可以通过工程讄��Q?/span>Setting...\C/C++ \Code Generation��进行选择�Q�缺省状态�ؓ__cdecl�?/span>

名字修饰�U�定�Q?/span>

1、修饰名(Decoration name)�Q?/span>"C"或�?/span>"C++"函数在内部（�~�译和链接）通过修饰名识�?/span>
2�?/span>C�~�译时函数名修饰�U�定规则�Q?/span>
__stdcall调用�U�定在输出函数名前加上一个下划线前缀�Q�后面加上一�?/span>"@"�W�号和其参数的字节数�Q�格式�ؓ_functionname@number,例如�Q?/span>function(int a, int b)�Q�其修饰名�ؓ�Q?/span>_function@8
__cdecl调用�U�定仅在输出函数名前加上一个下划线前缀�Q�格式�ؓ_functionname�?/span>
__fastcall调用�U�定在输出函数名前加上一�?/span>"@"�W�号�Q�后面也是一�?/span>"@"�W�号和其参数的字节数�Q�格式�ؓ@functionname@number�?/span>

3�?/span>C++�~�译时函数名修饰�U�定规则�Q?/span>
__stdcall调用�U�定�Q?/span>
1)、以"?"标识函数名的开始，后跟函数名；
2)、函数名后面�?/span>"@@YG"标识参数表的开始，后跟参数表；
3)、参数表以代可��C�：
X--void �Q?/span>
D--char�Q?/span>
E--unsigned char�Q?/span>
F--short�Q?/span>
H--int�Q?/span>
I--unsigned int�Q?/span>
J--long�Q?/span>
K--unsigned long�Q?/span>
M--float�Q?/span>
N--double�Q?/span>
_N--bool�Q?/span>
PA--表示指针�Q�后面的代号表明指针�c�d��Q�如果相同类型的指针�q�箋出现�Q�以"0"代替�Q�一�?/span>"0"代表一�ơ重复；
4)、参数表的第一��ؓ该函数的�q�回值类型，其后依次为参数的数据�c�d��,指针标识在其所指数据类型前�Q?/span>
5)、参数表后以"@Z"标识整个名字的结束，如果该函数无参数�Q�则�?/span>"Z"标识�l�束�?/span>
其格式�ؓ"?functionname@@YG*****@Z"�?/span>"?functionname@@YG*XZ"�Q�例�?/span>
  int Test1(char *var1,unsigned long)----"?Test1@@YGHPADK@Z"

void Test2()-----“?Test2@@YGXXZ”

__cdecl调用�U�定�Q?/span>
规则同上面的_stdcall调用�U�定�Q�只是参数表的开始标识由上面�?/span>"@@YG"变�ؓ"@@YA"�?/span>
__fastcall调用�U�定�Q?/span>
规则同上面的_stdcall调用�U�定�Q�只是参数表的开始标识由上面�?/span>"@@YG"变�ؓ"@@YI"�?/span>
VC++对函数的省缺声明�?/span>"__cedcl",��只能被C/C++调用.

注意�Q?/span>
1�?/span>_beginthread需�?/span>__cdecl的线�E�函数地址�Q?/span>_beginthreadex�?/span>CreateThread需�?/span>__stdcall的线�E�函数地址�?/span>

2、一�?/span>WIN32的函数都�?/span>__stdcall。而且�?/span>Windef.h中有如下的定义：
#define CALLBACK __stdcall
#define WINAPI　 __stdcall

3�?/span>extern "C" _declspec(dllexport) int __cdecl Add(int a, int b);
   typedef int (__cdecl*FunPointer)(int a, int b);
   修饰�W�的书写��序如上�?/span>

4�?/span>extern "C"的作用：如果Add(int a, int b)是在c语言�~�译器编译，而在c++文�g使用�Q�则需要在c++文�g中声明：extern "C" Add(int a, int b)�Q�因�?/span>c�~�译器和c++�~�译器对函数名的解释不一��P��c++�~�译器解释函数名的时候要考虑函数参数�Q�这��h��了方便函数重载，而在c语言中不存在函数重蝲的问题）�Q��?/span>extern "C"�Q�实质就是告�?/span>c++�~�译器，该函数是c库里面的函数。如果不使用extern "C"则会出现链接错误�?/span>
一般象如下使用�Q?/span>
#ifdef _cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C extern
#endif

#ifdef _cplusplus
extern "C"{
#endif
EXTERN_C int func(int a, int b);
#ifdef _cplusplus
}
#endif

5�?/span>MFC提供了一些宏�Q�可以��?/span>AFX_EXT_CLASS来代�?/span>__declspec(DLLexport)�Q��ƈ修饰�c�d��Q�从而导出类�Q?/span>AFX_API_EXPORT来修饰函敎ͼ�AFX_DATA_EXPORT来修饰变�?/span>
AFX_CLASS_IMPORT�Q?/span>__declspec(DLLexport)
AFX_API_IMPORT�Q?/span>__declspec(DLLexport)
AFX_DATA_IMPORT�Q?/span>__declspec(DLLexport)
AFX_CLASS_EXPORT�Q?/span>__declspec(DLLexport)
AFX_API_EXPORT�Q?/span>__declspec(DLLexport)
AFX_DATA_EXPORT�Q?/span>__declspec(DLLexport)
AFX_EXT_CLASS�Q?/span>#ifdef _AFXEXT
   AFX_CLASS_EXPORT
        #else
   AFX_CLASS_IMPORT

6�?/span>DLLMain负责初始�?/span>(Initialization)和结�?/span>(Termination)工作�Q�每当一个新的进�E�或者该�q�程的新的线�E�访�?/span>DLL�Ӟ��或者访�?/span>DLL的每一个进�E�或者线�E�不再��?/span>DLL或者结束时�Q�都会调�?/span>DLLMain。但是，使用TerminateProcess�?/span>TerminateThread�l�束�q�程或者线�E�，不会调用DLLMain�?/span>

7、一�?/span>DLL在内存中只有一个实�?/span>
DLL�E�序和调用其输出函数的程序的关系�Q?/span>
1)�?/span>DLL与进�E�、线�E�之间的关系
DLL模块被映��到调用它的�q�程的虚拟地址�I�间�?/span>
DLL使用的内存从调用�q�程的虚拟地址�I�间分配�Q�只能被该进�E�的�U�程所讉K��?/span>
DLL的句柄可以被调用�q�程使用�Q�调用进�E�的句柄可以�?/span>DLL使用�?/span>
DLLDLL可以有自��q��数据�D�，但没有自��q��堆栈�Q��用调用进�E�的栈，与调用它的应用程序相同的堆栈模式�?/span>

2)、关于共享数据段
DLL定义的全局变量可以被调用进�E�访问；DLL可以讉K��调用�q�程的全局数据。��用同一DLL的每一个进�E�都有自��q��DLL全局变量实例。如果多个线�E��ƈ发访问同一变量�Q�则需要��用同步机�Ӟ��对一�?/span>DLL的变量，如果希望每个使用DLL的线�E�都有自��q��|��则应该��用线�E�局部存�?/span>(TLS�Q?/span>Thread Local Strorage)�?/span>

Visual C++ Compiler Options可以指定�?span>Calling Convention�?/span> 3�U�：
    /Gd /Gr /Gz

    �q�三个参数决定了�Q?span>

    1.函数参数以何�U�顺序入栈，叛_��左还是左到右�?span>
    2.在函数运行完后，是调用函数还是被调用函数清理入栈的参数�?span>
    3.在编译时函数名字是如何�{换的�?span>

    下面我们分别详细介绍�Q?span>

    1./Gd
        �q�是�~�译器默认的转换模式�Q�对一般函��C��?/span> C的函数调用�{换方�?span>__cdecl�Q?span>
        但是对于C++ 成员函数和前面修��C��__stdcall __fastcall的函数除外�?span>

    2./Gr
        对于一般函��C��?span>__fastcall函数调用转换方式�Q�所有��?span>__fastcall的函�?span>
        必须要有函数原�Ş。但对于C++ 成员函数和前面修��C��__cdecl __stdcall 的函数除外�?span>

    3./Gz
        对于所�?/span> C函数使用__stdcall函数调用转换方式�Q�但对于可变参数�?/span> C函数�?span>
        及用__cdecl __fastcall修饰�q�的函数�?span>C++ 成员函数除外。所有用__stdcall
        修饰的函数必��L��函数原�Ş�?span>

        事实上，对于x86�pȝ��Q?span>C++ 成员函数的调用方式有点特别，��成员函数的this
        指针攑օ�ECX�Q�所有函数参��C��叛_��左入栈，被调用的成员函数负责清理入栈�?span>
        参数。对于可变参数的成员函数�Q�始�l��?span>__cdecl的�{换方式�?span>

    下面该进入主题，分别讲一下这三种函数调用转换方式有什么区别：

    1.__cdecl
        �q�是�~�译器默认的函数调用转换方式�Q�它可以处理可变参数的函数调用。参�?span>
        的入栈顺序是从右向左。在函数�q�行�l�束后，��p��用函数负责清理入栈的参数�?span>
        在编译时�Q�在每个函数前面加上下划�U?span>(_)�Q�没有函数名大小写的转换。即
                　　_functionname

    2.__fastcall
        有一些函数调用的参数被放�?span>ECX�Q?span>EDX中，而其它参��C��叛_��左入栈。被调用
        函数在它��要�q�回时负责清理入栈的参数。在内嵌汇编语言的时候，需要注�?span>
        寄存器的使用�Q�以免与�~�译器��用的产生冲突。函数名字的转换是：
                　　@functionname@number
        没有函数名大��写的�{换，number表示函数参数的字节数。由于有一些参��C��
        需要入栈，所以这�U��{换方式会在一定程度上提高函数调用的速度�?span>

    3.__stdcall
    　　函数参数从右向左入栈�Q�被调用函数负责入栈参数的清理工作。函数名转换�?span>
    　　式如下：
        　　　　    _functionname@number

    下面我们亲自写一个程序，看看各种不同的调用在�~�译后有什么区别，我们的被�?span>
    用函数如下：

    int function(int a, int b)
    {
        return a + b;
    }

    void main()
    {
        function(10, 20);
    }

    1.__cdecl

        _function
                 push    ebp
                 mov     ebp, esp
                 mov     eax, [ebp+8]       ;参数1
                 add     eax, [ebp+C]       ;加上参数2
                 pop     ebp
                 retn
        _main
                 push    ebp
                 mov     ebp, esp
                 push    14h                ;参数 2入栈
                 push    0Ah                ;参数 1入栈
                 call    _function          ;调用函数
                 add     esp, 8             ;修正�?span>
                 xor     eax, eax
                 pop     ebp
                 retn

    2.__fastcall

        @function@8
                 push    ebp
                 mov     ebp, esp           ;保存栈指�?span>
                 sub     esp, 8             ;多了两个局部变�?span>
                 mov     [ebp-8], edx       ;保存参数 2
                 mov     [ebp-4], ecx       ;保存参数 1
                 mov     eax, [ebp-4]       ;参数 1
                 add     eax, [ebp-8]       ;加上参数 2
                 mov     esp, ebp           ;修正�?span>
                 pop     ebp
                 retn
        _main
                 push    ebp
                 mov     ebp, esp
                 mov     edx, 14h           ;参数 2�l?span>EDX
                 mov     ecx, 0Ah           ;参数 1�l?span>ECX
                 call    @function@8        ;调用函数
                 xor     eax, eax
                 pop     ebp
                 retn

    3.__stdcall

        _function@8
                 push    ebp
                 mov     ebp, esp
                 mov     eax, [ebp]         ;参数 1
                 add     eax, [ebp+C]       ;加上参数 2
                 pop     ebp
                 retn    8                  ;修复�?span>
        _main
                 push    ebp
                 mov     ebp, esp
                 push    14h                ;参数 2入栈
                 push    0Ah                ;参数 1入栈
　               call    _function@8　　　　;函数调用
                 xor     eax, eax
                 pop     ebp
                 retn

    可见上述三种�Ҏ��各有各的特点�Q�而且_main必须�?span>__cdecl�Q�一�?span>WIN32的函数都�?span>
    __stdcall。而且�?span>Windef.h中有如下的定义：

    #define CALLBACK __stdcall
    #define WINAPI　 __stdcall

心羽 2010-10-17 19:37 发表评论

【分享】C数组与指针学习笔�?

心羽 — Wed, 13 Oct 2010 01:58:00 GMT
文章标题�? c数组与指针学习笔�?br>【文章作者�? evilkis
--------------------------------------------------------------------------------------------------------
1.数组的定�?br>int a[5];定义了一个数�l�a,它可以存�?个整型数据，注意�Q�在定义了一个数�l�时�Q�编译系�l�会按照数组�c�d��和数�l�元素个数来分配一�D�连�l�的存储�I�间来存储数�l�元素。则数组存放数组a的空间大��ؓ5*sizeof(int)= 20字节�?br>
2 数组的引�?br>当我们引用数�l�元素时下标�?开始，��于元素的个敎ͼ�且只能逐个引用数组元素�Q�而不能直接引用整个数�l�。如�Q�int a[2]={1,2};int b[2]=a;�q�句��是错误的！原因是引用了整个数组�?br>
3数组在内存中的存�?br>数组在内存中式按照下标的��序来一�ơ存攄��可以理解为线性存放，多维数组也是按照�q�个��序存放
4 数组的初始化
数组的初始化可以在定义的时候用{}全部赋�?nbsp;如int a[2]={1,2};如果把定义和赋值分开那就错了如：int a[2];a[2]={1,2};其中�W�二句本意是�?,2赋值给数组a,但是此时a[2]的意义变了，他不在代表一个数�l�，而是下标引用数组元素�Q�即数组a的第1个元素。所以数�l�初始化的赋值方式只能在数组定义时��用，定义之后在赋��|��只能一个元素一个元素的赋�?br>
5 多维数组
多维数组��单的如二�l�数�l�，他其实可以看成一个特�D�的一位数�l�，他的元素是一个一�l�数�l�，例如�Q�int a[2][3]可以看做�?个一�l�数�l�a[0]和a[1]�l�成�?br>好了��单的了解了下数组的基本知识，现在我么开始讨��Z��些常见的问题

数组名是什么？�{��h于指针？
数组名是一个地址�Q�而且是一个不可被修改的常量。这一点类��g��W�号帔R��Q�数�l�名�q�个�W�号代表了容�U�x��l�的那块内存的首地址�Q�注意：不是数组名的值是那块内存的首地址�Q�数�l�名本��n没有地址�Q�只是代表了那块地址�Q�他是一个右��|��而指针是一个左��|��所以数�l�名与指针不同。例如：int a[3];虽然数组名a没有地址�Q�但是对其取地址&a,得到的依然是数组首地址。把数组名想象成一个符号常量即可，��x��l�名没有地址�Q�只是代表了�q�个数组的首地址。又因�ؓ数组名是个地址帔R��所以不能修改它的��|��即a++�Q�a--是错误的�Q�只有两�U�情冉|��l�名不表�C�地址帔R��
即sizeof�Q�a�Q�和&a�Q�前者表�C�数�l�的整个长度�Q�后者是数组地址�Q�但�q�不意味着a有地址,数组名是数组元素的首地址�Q�不是数�l�的首地址

一�l�数�l�的��d��公式
如int a[6];
则a[n]的地址�?int)a+sizeof(int)*n(当然n<=6),其原理即�Q�首地址+偏移地址其中a一定要做强制类型�{换因为a是有�c�d��的，必须把其转换成整敎ͼ�sizeof(int)��x��一个元素的大小
推而广�?br>对于TYPE array[m];
则array[n]的地址�?(int)array+sizeof(TYPE)*n(n<=m)//做逆向的时候很有用
二维数组的寻址公式
�?int a[4][5]
则a[2][3]的地址�?(int)a+sizeof(int[5])*2+sizeof(int)*3
                  |           |            |
                  |           |            |
             数组首地址    行偏�U?nbsp;     列偏�U?br>卻I��先算��定在第几行�Q�在��定在第几列最后加上首地址
或者第二种方式�Q?br>a[2][3]的地址�?(int)a+sizeof(int)*(2*5+3)
                          |
                          |
       直接定位元素看跨��了多少个元素然后乘以他们的数据�c�d��大小
因�ؓ数组a每一行有5个元素故2*5,3是目标行的元素偏�U?br>故推而光�?br>对于TYPE array[x][y]二维数组
则array[m][n]的地址�?(int)a+sizeof(int[y])*m+sizeof(TYPE)*n
或array[m][n]的地址�?(int)a+sizeof(TYPE)*(m*y+n)
�q�些��d��公式在逆向�q�程中很有用�Q�至��看到这��L��d��方式我们应该能想到是个数�l�，其实把数�l�在内存中的存放��x��U�性的��很好理解这些寻址�Ҏ��?br>
实践一下：
        int a[5]={0,1,2,3,4};
        int b;
        b=*((int)a+sizeof(int)*2);
   问b是否能取到a[2]的�?
如果你说不能�Q�恭喜你�Q�你很理解地址与数值的概念�Q�如果你说能�Q�也不能怪你�Q�下面我们就分析一下地址和数值的关系�Q�由上面的讲�q�我们知�?(int)a+sizeof(int)*2)�q�里得到的确��实实是a[2]的地址�Q�然后对地址取内容理所当然取的是a[2]的值啊�Q�呵呵，初学者可能都会这么想�Q�但是那都是我们一厢情愿所造成的，其实((int)a+sizeof(int)*2)只是一个整敎ͼ�不是地址的含义，没有��M��指向意义�Q�也��是a[2]的地址值等�?(int)a+sizeof(int)*2)�Q�但是�ƈ不意味着((int)a+sizeof(int)*2)是地址�Q�实际上地址本来��是一个基本数据类型，也就是说地址是有指向意义有类型这是地址和地址值的区别�Q�如果没有类型，操作�pȝ��从这首地址取值根本不知道要取多少字节�Q?br>所以我们要加上强制�c�d��转换�Q��他有�c�d��有指向意义即若改�?(int*)((int)a+sizeof(int)*2)卛_��取到a[2]的�?br>

4 数组名作函数参数
当数�l�名作函数参数时�Q�传递的是数�l�首地址的一份拷贝，虽然数组名不可以自加�Q�但是�Ş参可以这里注意，因�ؓ形参是变量，存放的只是数�l�首地址的一份拷贝�?br>
6指针
指针的定义：
通俗的讲�Q�指针就是一个变量，他存攑֏�一个变量的地址�Q�特�D�就�Ҏ��在它存放的是地址�?br>弄清关于指针�?个方面的内容�Q�指针的�c�d�� 指针所指向的类�?nbsp;指针的�?nbsp;指针本��n所占的内存�?br>如：
1指针的类�?br>把指针的名字��L��剩下的就是指针的�c�d��Q?br>int *p                  //指针的类型�ؓ int*
char **p               //指针的类型�ؓchar**
int (*p)[5]              //指针得到�c�d��为int(*)[5]
�?2位��^��C��里所有指针类型的大小均�ؓ4字节
2 指针所指向的类�?br>当我们通过指针来访问指针所指向的内存区�Ӟ��指针的所指向的类型决定了�~�译器将那块内存里的内容当做什么来看待
把指针的名字和指针声明符*��L��Q�剩下的��x��针所指向的类�?br>int *p           //指针所指向的类型�ؓint
char **p         //指针所指向的类型�ؓint*即p指向一个指�?br>int (*p)[5]        //指针所指向的类型�ؓint()[5]
3指针的�?br>指针的值指针变量存攄��地址��|��他指向首地址��Z��的一片内存区�Q�大��ؓsizeof(指针所指向的类�?
4 指针本��n所占的内存�?br>因�ؓ指针也是一个变量，所以指针本�w�也占内存，�?2�q�_��下大��ؓ4字节
�q�算�W?amp;�?
&a的结果是产生了一个指针，*p的结果是p所指向的东�?br>
指针的运��?br>指针加减一个整型数据得到的�q�是一个指针，指针加减一个指针得到的是一个整型数据�?br>
关于复杂的指针声�?br>指针数组:�?nbsp;int *ptr[10],首先它是一个含有是个元素的数组�Q�其�ơ元素类型�ؓint*,卛_��素�ؓ指针�Q?br>数组指针�Q�int (*p)[10]�Q�首先他是一个指针，其次他指向一个int[10]的数�l?br>如果实在弄�؜的话��想想牛奶和奶牛的区别，牛奶是奶�Q�而奶牛是�?即中国�h说话主语都在后面�Q�说堆栈�Q�其实说的是�?
函数指针:
int (*p) (int x,int y)因�ؓ指针指向函数而函数名的类型�ؓint(int x,int y)�Q�所以定义的时候相当于 int (int x,int y) (*p)
如果�?p两边的括号去掉则int *p(int x,int y)表示函数p�q�回值是个指�?br>9 二维数组与指�?br>
int ptr[2][3]={1,2,3,4,5,6};
关于二维数组主要��是要搞清楚数组的指�?nbsp;某一行的指针某一行某一列的指针之间的区�?br>单纯的数�l�名ptr则是数组�W?行的指针 �Ҏ��向第0行，同理ptr+1指向�W?行，�q�两个均��指针�Q�问题来�?nbsp;*(ptr+1)可能有很多�h认�ؓ它的��gؓ4�Q�即ptr[1][0]的��|��因�ؓptr+1是第1行的首地址�Q�所以对其取内容应该为ptr[1][0]的��|��实际上是错的因�ؓ ptr+1是一个行指针而我们要取元素的话要使用列指针，所以要做个强制�c�d��转换 �?(ptr+1)为列指针其��g��ptr+1的值相�{�但意义不同如果不理解请接着�?br>例如�Q�int a[i]
�q�样数组名加下标的�Ş式，被编译器理解�?br>*(a+i)
同理�Q�a[i][j]被理解�ؓ�Q?br>         *(a[i] + j)
            �Q?nbsp;*(*(a + i) + j)
a+1表示a[1]的地址�Q�a[1]表示a[1][0]的地址,��管他们的值是一��L��Q?br>
其实数组与指针�ƈ不难�Q�只要��^时多�l�习多用久而久之就会了。笔记就到这里了写的比较乱，希望对初学者有所帮助�Q�有不对的地方请指正

心羽 2010-10-13 09:58 发表评论

函数成员变量

心羽 — Fri, 08 Oct 2010 14:20:00 GMT

class base
{
public:
base(int i):m_j(i),m_i(m_j)
{

}
int get_i()
{
  return m_i;
}
int get_j()
{
  return m_j;
}
protected:
private:
int m_i;
int m_j;
};

int main(int argc, char* argv[])
{
base obj(98);
cout << obj.get_i() << endl
  << obj.get_j() << endl;
return 0;
}

在带参数的构造函��C��Q�初始化列表的初始化变量��序是根据成员变量的声明��序来执行的�Q�因此m_i会被
赋予一个随机��|��输出�?br>-858993460
98
如果在声明变量�ؓ
int m_j;
int m_i;
��׃��输出正常�?
98
98

class A
{
   const int Size = 0;
}

是错误的�Q�常量必��d��构造函数的初始化列表里面初始化
�?br>
class A
{
   A()
  {
  const int Size = 10;
}
};

心羽 2010-10-08 22:20 发表评论

static用法�ȝ��

心羽 — Thu, 26 Aug 2010 01:07:00 GMT

用static声明的函数和变量��结

static 声明的变量在C语言中有两方面的特征�Q?br>　　1)、变量会被放在程序的全局存储��Z��Q�这样可以在下一�ơ调用的时候还可以保持原来的赋倹{��这一�Ҏ��它与堆栈变量和堆变量的区别�?br>　　2)、变量用static告知�~�译器，自己仅仅在变量的作用范围内可见。这一�Ҏ��它与全局变量的区别�?br>Tips:
　　A.若全局变量仅在单个C文�g中访问，则可以将�q�个变量修改为静态全局变量�Q�以降低模块间的耦合度；
　　B.若全局变量仅由单个函数讉K��Q�则可以��这个变量改��函数的静态局部变量，以降低模块间的耦合度；
　　C.设计和��用访问动态全局变量、静态全局变量、静态局部变量的函数�Ӟ��需要考虑重入问题�Q?br>        D.如果我们需要一个可重入的函敎ͼ�那么�Q�我们一定要避免函数中��用static变量(�q�样的函数被�U�Cؓ�Q�带“内部存储�?#8221;功能的的函数)
        E.函数中必��要使用static变量情况:比如当某函数的返回��gؓ指针�c�d��Ӟ��则必��L��static的局部变量的地址作�ؓ�q�回��|��若�ؓauto�c�d��Q�则�q�回为错指针�?o:p>

函数前加static使得函数成�ؓ静态函数。但此处“static”的含义不是指存储方式�Q�而是指对函数的作用域仅局限于本文�?所以又�U�内部函�?。��用内部函数的好处是：不同的�h�~�写不同的函数时�Q�不用担心自己定义的函数�Q�是否会与其它文件中的函数同名�?o:p>

扩展分析:术语static有着不寻常的历史.起初�Q�在C中引入关键字static是�ؓ了表�C�退��Z��个块后仍然存在的局部变量。随后，static在C中有了第二种含义�Q�用来表�C�Z��能被其它文�g讉K��的全局变量和函数。�ؓ了避免引入新的关键字�Q�所以仍使用static关键字来表示�q�第二种含义。最后，C++重用了这个关键字�Q��ƈ赋予它与前面不同的第三种含义�Q�表�C�属于一个类而不是属于此�cȝ��M��特定对象的变量和函数(与Java中此关键字的含义相同)�?o:p>

全局变量、静态全局变量、静态局部变量和局部变量的区别

变量可以分�ؓ�Q�全局变量、静态全局变量、静态局部变量和局部变量�?br>          按存储区域分�Q�全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存攑֜�内存的栈区�?br>          按作用域分，全局变量在整个工�E�文件内都有效；静态全局变量只在定义它的文�g内有效；静态局部变量只在定义它的函数内有效�Q�只是程序仅分配一�ơ内存，函数�q�回后，该变量不会消失；局部变量在定义它的函数内有效，但是函数�q�回后失效�?o:p>

全局变量(外部变量)的说明之前再冠以static ��构成了静态的全局变量。全局变量本��n��是静态存储方式，静态全局变量当然也是静态存储方式�?�q�两者在存储方式上�ƈ无不同。这两者的区别虽在于非静态全局变量的作用域是整个源�E�序�Q?当一个源�E�序由多个源文�g�l�成�Ӟ��非静态的全局变量在各个源文�g中都是有效的�?而静态全局变量则限制了其作用域�Q?卛_��在定义该变量的源文�g内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文�g内，只能��源文件内的函数公用，因此可以避免在其它源文�g中引起错误�?

　　从以上分析可以看出，把局部变量改变�ؓ静态变量后是改变了它的存储方式��x��变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的��用范围�?o:p>

　　static函数与普通函��C��用域不同。仅在本文�g。只在当前源文�g中��用的函数应该说明为内部函�?static)�Q�内部函数应该在当前源文件中说明和定义。对于可在当前源文�g以外使用的函敎ͼ�应该在一个头文�g中说明，要��用这些函数的源文件要包含�q�个头文�?o:p>

　　static全局变量与普通的全局变量有什么区别：static全局变量只初始化一�ơ，防止在其他文件单元中被引�?
　　static局部变量和普通局部变量有什么区别：static局部变量只被初始化一�ơ，下一�ơ依据上一�ơ结果��|��
       static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中�l�持一份拷�?br>       全局变量和静态变量如果没有手工初始化�Q�则��q��译器初始化�ؓ0。局部变量的��g��可知�?o:p>

.先来介绍它的�W�一条也是最重要的一条：隐藏�?
当我们同时编译多个文件时�Q�所有未加static前缀的全局变量和函数都��h��全局可见性。�ؓ理解�q�句话，我�D例来说明。我们要同时�~�译两个源文�Ӟ��一个是a.c�Q�另一个是main.c.

下面是a.c的内容：

char a = 'A'; // global variable void msg() { printf("Hello\n"); }

下面是main.c的内容：

int main(void) { extern char a; // extern variable must be declared before use printf("%c ", a); (void)msg(); return 0; }

�E�序的运行结果是�Q?/p>
A Hello

你可能会问：��Z��么在a.c中定义的全局变量a和函数msg能在main.c中��用？前面说过�Q�所有未加static前缀的全局变量和函数都��h��全局可见性，其它的源文�g也能讉K��。此例中�Q�a是全局变量�Q�msg是函敎ͼ��q�且都没有加static前缀�Q�因此对于另外的源文件main.c是可见的�?/p>
如果加了static�Q�就会对其它源文仉��藏。例如在a和msg的定义前加上static�Q�main.c��q��不到它们了。利用这一�Ҏ��可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲�H�。Static可以用作函数和变量的前缀�Q�对于函数来�Ԍ��static的作用仅限于隐藏�Q�而对于变量，static�q�有下面两个作用�?/p>
2.static的第二个作用是保持变量内容的持久�?/p>
存储在静态数据区的变量会在程序刚开始运行时��完成初始化�Q�也是唯一的一�ơ初始化。共有两�U�变量存储在静态存储区�Q�全局变量和static变量�Q�只不过和全局变量比�v来，static可以控制变量的可见范��_��说到底static�q�是用来隐藏的。虽然这�U�用法不常见�Q�但我还是�D一个例子�?/p>

#include �Q�stdio.h�Q? int fun(void){ static int count = 10; // 事实上此赋��D��句从来没有执行过 return count--; } int count = 1; int main(void) { printf("global\t\tlocal static\n"); for(; count �Q? 10; ++count) printf("%d\t\t%d\n", count, fun()); return 0; }

�E�序的运行结果是�Q?br>

global local static
1 10
2   9
3   8
4   7
5   6
6   5
7   4
8   3
9   2
10  1

3.static的第三个作用是默认初始化�?.其实全局变量也具备这一属性，因�ؓ全局变量也存储在静态数据区�?/p>
在静态数据区�Q�内存中所有的字节默认值都�?x00�Q�某些时候这一特点可以减少�E�序员的工作量。比如初始化一个稀疏矩阵，我们可以一个一个地把所有元素都�|?�Q�然后把不是0的几个元素赋倹{��如果定义成静态的�Q�就省去了一开始置0的操作。再比如要把一个字�W�数�l�当字符串来用，但又觉得每次在字�W�数�l�末��֊�‘\0’太麻烦。如果把字符串定义成静态的�Q�就省去了这个麻烦，因�ؓ那里本来��是‘\0’。不妨做个小实验验证一下�?/p>

#include �Q�stdio.h�Q? int a; int main(void) { int i; static char str[10]; printf("integer: %d; string: (begin)%s(end)", a, str); return 0; }

�E�序的运行结果如下integer�Q?0�Q?string�Q?�Q�begin�Q�（end�Q?/p>
最后对static的三条作用做一句话�ȝ��。首先static的最主要功能是隐藏，其次因�ؓstatic变量存放在静态存储区�Q�所以它具备持久性和默认�?.

心羽 2010-08-26 09:07 发表评论

零值比�?-BOOL�Q�int�Q�float�Q�指针变量与零值比较的if语句

心羽 — Thu, 26 Aug 2010 00:36:00 GMT

�q�是�E�序员面试的一道常见题�Q�也是个C++基础问题。若只在大学里看�q�几本基��的编�E�入门书�Q�看见这道题可能会觉得奇怪，不就是和0比较吗，直接拿出来比��是了，其实非也。下文引自google搜烦�l�果�Q�出处不详，高手可以无视�Q�菜菜留下，记得做好�W�记�?br>首先�l�个提示�Q�题目中要求的是零值比较，而非�?�q�行比较�Q�在C++�?#8220;零�?#8221;的范围可��大了，可以�?�Q?0.0 �Q?FALSE或�?#8220;�I�指�?#8221;�?br>int型变�?n �?#8220;零�?#8221;比较�?if 语句��是�Q?/strong>

if ( n == 0 )

if ( n != 0 )

如下写法均属不良风格.�?br>
if ( n )               // 会让��?n 是布��变�?br>
if ( !n   )

BOOL flag �?#8220;零�?#8221;比较�?if 语句:

�?据布��类型的语义�Q�零��gؓ“�?#8221;�Q�记为FALSE�Q�，��M��非零值都�?#8220;�?#8221;�Q�记为TRUE�Q�。TRUE 的值究竟是什么�ƈ没有�l�一的标准。例如Visual C++ ��TRUE 定义�?�Q�而Visual Basic 则将TRUE 定义�?1。所以我们不可以��布��变量直接与TRUE、FALSE 或�?�? �q�行比较�?br>
标准�{�案�Q?br>
if ( flag )

if ( !flag )

如下写法均属不良风格�?br>
if (flag == TRUE)

if (flag == 1 )

if (flag == FALSE)

if (flag == 0)

float x �?#8220;零�?#8221;比较�?if 语句:
千万要留意，无论是float �q�是double �c�d��的变量，都有�_�ֺ�限制�Q�都不可以用“==”�?#8220;�Q?”与�Q何数字比较，应该设法转化�?#8220;>=”�?#8220;<=”形式�?��Z��么？文章之后有详�l�的讨论�Q�可参�?

假设��点变量的名字�ؓx�Q�应当将

if (x == 0.0)         // 隐含错误的比�?br>
转化�?br>
if ((x>=-EPSINON) && (x<=EPSINON))

其中EPSINON 是允许的误差�Q�即�_�ֺ��Q��?br>
标准�{�案�C�Z��Q?br>
const float EPSINON = 0.00001;

if ((x >= - EPSINON) && (x <= EPSINON)

如下是错误的写法�?br>
if (x == 0.0)

if (x != 0.0)

char *p �?#8220;零�?#8221;比较�?if 语句:

标准�{�案�Q?br>
if (p == NULL)

if (p != NULL)

如下写法均属不良风格�?br>
if (p == 0)         // �Ҏ��让�h误解p是整型变�?br>
if (p != 0)

if (p)                 // �Ҏ��让�h误解p是bool型变�?br>
if (!p)

�?上的不良风格很多都能通过�~�译�Q�但是语句�ƈ不能很好的表达与零��D��行比较的逻辑依据。一般的�Q�如果想�?if 语句判断一个变量的真假�Q�应该直接��用if�Q�var�Q�、if�Q�！var�Q�，表明�?if 语句的功能�ؓ“逻辑”判断�Q�如果想�?if 语句判断一个数值型变量�Q�short、int、long�{�）�Q�应该用if�Q�var==0�Q�，表明�?if 语句是将变量�?�q�行“数�?#8221;上的比较�Q�而检视指针是否�ؓ�I�则适宜用if�Q�var==NULL�Q�，�q�是一�U�很好的�~�程习惯�?br>
��点型变量�ƈ不精��，所以不可将float变量�?#8220;==”�?#8220;�Q?”与数字比较，应该设法转化�?#8220;>=”�?#8220;<=”形式。如果写成if �Q�x == 0.0�Q�，则判为错�Q�得0分。以下给��l�原因：
��点数在内存中的存贮机制和整型数不同�Q�有舍入误差�Q�在计算��Z��用以�q�似表示��L��某个实数。具体的��_��q�个实数�׃��个整数或定点敎ͼ�卛_��敎ͼ�乘以某个基数�Q�计��机中通常�?�Q�的整数�ơ幂得到�Q�这�U�表�C�方法类��g��基数�?0的科学记数法�?
所以��Q�Ҏ��在运��过成功�q�算通常伴随着因�ؓ无法�_��表示而进行的�q�似或舍入。但是这�U�设计的好处是可以在固定的长度上存储更大范围的数�?
例如�Q�一个指数范围�ؓ±4�?位十�q�制��点数可以用来表�C?3210�Q?.321�?.0004321�Q�但是没有��够的�_�ֺ�来表�C?32.123�?3212.3�Q�必��近��gؓ432.1�?3210�Q�。当�Ӟ��实际使用的位数通常�q�大�?�?
所以��Q�Ҏ��不能够判断相�{�，�?if(x==0)的这��L��~�码是不��L��正确的，我们在判断��Q�Ҏ��相等�Ӟ��推荐用范围来��定�Q�若x在某一范围内，我们��p��为相�{�，至于范围怎么定义�Q�要看实际情况而已了，float�Q�和double 各有不同
所以const float EPSINON = 0.00001;
if ((x >= - EPSINON) && (x <= EPSINON) �q�样判断是可取的
至于��Z��么取0.00001�Q�可以自己按实际情况定义

再看下面CSDN上的回答

引用

#define   E   1.0E-6

float   x   �?#8220;零�?#8221;比较的if
-----------------------

��点数是不可以直接比较大��的�Q�因为是非精��存储，只能讄��一个精度，然后在允许误差内的就认�ؓ是相�{�的�Q�对��点型数比较的时候用==是不对的

#define   E   0.000001

fabs((a+b)+c)   -   ((b+a)+c))

心羽 2010-08-26 08:36 发表评论

C++高效�~�程忠告

心羽 — Wed, 25 Aug 2010 02:26:00 GMT
�q�是对C++高效�~�程的一个�ȝ��, 很有指导作用.

一�?include “filename.h”�?include 的区�?/span>
#include “filename.h”是指�~�译器将从当前工作目录上开始查找此文�g
#include 是指�~�译器将从标准库目录中开始查找此文�g

二、头文�g的作�?/span>
加强安全��?br>通过头文件可能方便地调用库功能，而不必关心其实现方式

三�? , &修饰�W�的位置
int *i,j; // better for read
i = new int(0);
j = 0;
int *&y = i; // pointer's reference
对于*�?amp;修饰�W�，��Z��避免误解�Q�最好将修饰�W�紧靠变量名
四、if语句
不要��布��变量与��M��D��行比较，那会很容易出错的�?br>整�Ş变量必须要有�c�d��相同的��D��行比�?br>��点变量最好少比相�{�，可以通过求差与较��的数比�?br>指针变量要和NULL�q�行比较�Q�不要和布尔型和整�Ş比较

五、const�?define的比�?/span>
const有数据类型，#define没有数据�c�d��
个别�~�译器中const可以�q�行调试�Q?define不可以进行调�?br>在类中定义常量有两种方式
1�?在类在声明常量，但不赋��|��在构造函数初始化表中�q�行赋��|��Q�常量和引用�c�d��的成员变量必��通过初始化列表来初始化赋��|��
2�?用枚举代替const帔R��?br>
六、C++函数中值的传递方�?/span>
有三�U�方式：��g��?Pass by value)、指针传�?Pass by pointer)、引用传�?Pass by reference)
void fun(char c) //pass by value
void fun(char *str) //pass by pointer
void fun(char &str) //pass by reference
如果输入参数是以��g��递的话，最好��用引用传递代替，因�ؓ引用传递省��M��临时对象的构造和析构
函数的返回类型不能省略，��q��没有也要加个void
七、函��C��中的指针或引用常量不能被�q�回
Char *func(void)
{
char str[]=”Hello Word”;
//�q�个是不能被�q�回的，因�ؓstr是个指定变量�Q�不是一般的��|��函数�l�束后会被注销�?br>//它是存放在栈中，函数�l�束后被注销�?br>//可以改�ؓ char *str = "HelloWorld",因�ؓ指针存放在全局作用域中�Q�函数结束后不会被注销
return str;
}
函数体内的指针变量�ƈ不会随着函数的消亡而自动释�?br>
八、一个内存拷贝函数的实现�?/span>
void *memcpy(void *pvTo,const void *pvFrom,size_t size)

{

assert((pvTo!=NULL)&&(pvFrom!=NULL));

byte *pbTo=(byte*)pvTo; //防止地址被改�?br>
byte *pbFrom=(byte*)pvFrom;

while (size-- >0)

pbTo++ = pbForm++;

return pvTo;

}
九、内存的分配方式
分配方式有三�U�，误��住，说不定那天去面试的时候就会有人问你这问题
1�?静态存储区�Q�是在程序编译时��已�l�分配好的，在整个运行期间都存在�Q�如全局变量、常量。（�E�序�~�译后运行时包含code和data两部分，其中data即�ؓ静态存储区分配�Q�程序一开始运行便分配整个data的东东）
2�?栈上分配�Q�函数内的局部变量就是从�q�分配的�Q�但分配的内存容易有限�?br>3�?堆上分配�Q�也�U�动态分配，如我们用new,malloc分配内存�Q�用delete,free来释攄��内存�?br>
十、内存分配的注意事项
用new或malloc分配内存�Ӟ��必须要对此指针赋初倹{�?br>用delete 或free释放内存后，必须要将指针指向NULL
不能修改指向帔R��的指针数�?br>十一、内容复制与比较
//数组……
char a[]=”Hello Word!”;
char b[10];
strcpy(b,a);
if (strcmp(a,b)==0)
{}

//指针……
char a[]=”Hello Word!”;
char *p;
p=new char[strlen(a)+1];
strcpy(p,a);
if (strcmp(p,a)==0)
{}

十二、sizeof的问�?/span>
��C��一点，C++无法知道指针所指对象的大小�Q�指针的大小永远�?字节
char a[]=”Hello World!”
char *p=a;
count<count< 而且�Q�在函数中，数组参数退化�ؓ指针�Q�所以下面的内容永远输出�?
void fun(char a[1000])
{
count<}

十三、关于指�?/span>
1�?指针创徏时必��被初始�?br>2�?指针在free 或delete后必��ȝ��为NULL
3�?指针的长度都�?字节
4、释攑ֆ�存时�Q�如果是数组指针�Q�必��要释放掉所有的内存�Q�如
char *p=new char[100];
strcpy(p,”Hello World”);
delete []p; //注意前面的��E�Q�号
p=NULL;
5、数�l�指针的内容不能��过数组指针的最大容易�?br>�?
char *p=new char[5];
strcpy(p,”Hello World”); //报错目标�Ҏ��不够�?br>delete []p; //注意前面的��E�Q�号
p=NULL;
十四、关于malloc/free 和new /delete
malloc/free 是C/C+的内存分配符�Q�new /delete是C++的内存分配符�?br>注意�Q�malloc/free是库函数�Q�new/delete是运��符
malloc/free不能执行构造函��C��析构函数�Q�而new/delete可以
new/delete不能在C上运行，所以malloc/free不能被淘�?br>两者都必须要成对��?br>C++中可以��用_set_new_hander函数来定义内存分配异常的处理

十五、��E++的特�?/span>
�Q?+新增加有重蝲(overload)�Q�内联（inline�Q�，Const�Q�Virtual四种机制
重蝲和内联：卛_��用于全局函数�Q�也可用于类的成员函敎ͼ�
Const和Virtual�Q�只可用于类的成员函敎ͼ�
重蝲�Q�在同一�c�M��Q�函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual关键字。和全局函数同名的函��C��叫重载。如果在�c�M��调用同名的全局函数�Q�必��ȝ��全局引用�W�号::引用�?br>覆盖是指�z��c�d��数覆盖基�c�d��敎ͼ�函数名相同；参数相同�Q�基�c�d��数必��L��Virtual关键字；不同的范�?�z��c�d��基类)�?br>隐藏是指�z��c�d��蔽了基类的同名函数相�?br>1�?函数名相同，但参��C��同，此时不论基类有无Virtual关键字，基类函数��被隐藏�?br>2�?函数名相同，参数也相同，但基�c�L��Virtual关键�?有就是覆�?�Q�基�c�d��数将被隐藏�?br>内联�Q�inline关键字必��M��定义体放在一��P��而不是单单放在声明中�?br>Const�Q�const是constant的羃写，“恒定不变”的意思。被const修饰的东襉K��受到强制保护�Q�可以预防意外的变动�Q�能提高�E�序的健壮性�?br>1�?参数做输入用的指针型参数�Q�加上const可防止被意外改动�?br>2�?按值引用的用户�c�d��做输入参数时�Q�最好将按��g��递的改�ؓ引用传递，�q�加上const关键字，目的是�ؓ了提高效率。数据类型�ؓ内部�c�d��的就没必要做�q��g事情�Q�如�Q?br>��void Func(A a) 改�ؓvoid Func(const A &a)�?br>而void func(int a)��没必要�Ҏ��void func(const int &a);
3�?�l�返回��gؓ指针�c�d��的函数加上const�Q�会使函数返回��g��能被修改�Q�赋�l�的变量也只能是const型变量。如�Q�函数const char*GetString(void); char *str=GetString()��会出错。而const char *str=GetString()��是正确的�?br>4�?Const成员函数是指此函��C��内只能调用Const成员变量�Q�提高程序的键壮性。如声明函数 int GetCount(void) const;此函��C��内就只能调用Const成员变量�?br>Virtual�Q�虚函数�Q�派生类可以覆盖掉的函数�Q�纯虚函敎ͼ�只是个空函数�Q�没有函数实��C��Q?br>十六、extern“C”有什么作用？
Extern “C”是由�Q�＋�Q�提供的一个连接交换指定符��P��用于告诉�Q�＋�Q�这�D�代码是�Q�函数。这是因为C++�~�译后库中函数名会变得很长，与C生成的不一��_��造成�Q�＋�Q�不能直接调用C函数�Q�加上extren “c”后，C++��p��直接调用C函数了�?br>Extern “C”主要使用正规DLL函数的引用和导出 �?在C++包含C函数或C头文件时使用。��用时在前面加上extern “c” 关键字即可�?br>十七、构造函��C��析构函数
�z��cȝ��构造函数应在初始化表里调用基类的构造函敎ͼ�
�z��c�d��基类的析构函数应加Virtual关键字�?br>不要��看构造函数和析构函数�Q�其实编��h��q�是不容易�?
#include
class Base
{
public:
virtual ~Base() { cout<< "~Base" << endl ; }
};

class Derived : public Base
{
public:
virtual ~Derived() { cout<< "~Derived" << endl ; }
};

void main(void)
{
Base * pB = new Derived; // upcast
delete pB;
}
输出�l�果为：
~Derived
~Base

如果析构函数不�ؓ虚，那么输出�l�果�?br>~Base
十八�?IFNDEF/#DEFINE/#ENDIF有什么作�?/span>
仿止该头文�g被重复引�?nbsp;
十九、三�l�数�l�一�ơ输�?br> int b[2][3][4]={{{0,1,2,3,},{4,5,6,7},{8,9,10,11}},{{12,13,14,15},{16,17,18,19},{20,21,22,23}}};
    int i,j;
    for(i=0,j=1;i<24;i++,j++)
    {
        printf("%3d",b[i/12][i%12/4][i%12%4]);
        if(j%4==0)
            printf("\n");
    }

心羽 2010-08-25 10:26 发表评论

心羽 — Mon, 23 Aug 2010 08:46:00 GMT

VC++里面定义字符串的时候，用_T来保证兼�Ҏ��。VC++支持ascii和unicode两种字符�c�d��Q�用_T可以保证从ascii�~�码�c�d��转换到unicode�~�码�c�d��的时候，�E�序不需要修攏V�?/p>
如果��来你不打算升��到unicode�Q�那么也不需要_T�?/p>
_t("hello world")

在ansi的环境下�Q�它是ansi的，如果在unicode下，那么它将自动解释为双字节字符�Ԍ��既unicode�~�码�?/p>
�q�样做的好处�Q�不��是ansi环境�Q�还是unicode环境�Q�都适用�?/p>
那么在VC++中，字符串_T("ABC")和一个普通的字符�?ABC"有什么区别呢�Q?/p>
_T("ABC")

如果定义了unicode�Q�它��表�C�ZؓL"ABC"�Q�每个字�W��ؓ16位，宽字�W�串�?/p>
如果没有定义unicode�Q�它��是ascii�?ABC"�Q�每个字�W��ؓ8位�?/p>
相当�?/p>
#ifdef _UNICODE

#define _T("ABC") L"ABC"

#else

#define _T("ABC") "ABC"

#endif

_T("ABC")中的一个字�W�和汉字一��P��占两个字节，而在"ABC"中，英文字符占一个字节，汉字占两个字节�?/p>
一�?在字�W�串前加一个L作用:

   �?L"我的字符�?   表示��ANSI字符串�{换成unicode的字�W�串�Q�就是每个字�W�占用两个字节�?/p>
strlen("asd") =   3;

strlen(L"asd") =   6;

   二�?nbsp; _T宏可以把一个引号引��h��的字�W�串�Q�根据你的环境设�|�，使得�~�译器会�Ҏ��~�译目标环境选择合适的�Q�Unicode�q�是ANSI�Q�字�W�处理方�?/p>
   如果你定义了UNICODE�Q�那么_T宏会把字�W�串前面加一个L。这�?_T("ABCD") 相当�?L"ABCD" �Q�这是宽字符丌Ӏ?/p>
   如果没有定义�Q�那么_T宏不会在字符串前面加那个L�Q�_T("ABCD") ��q��价于 "ABCD"

三、TEXT,_TEXT 和_T 一��L��

如下面三语句�Q?/p>
TCHAR szStr1[] = TEXT("str1");

char szStr2[] = "str2";

WCHAR szStr3[] = L("str3");

那么�W�一句话在定义了UNICODE时会解释为第三句话，没有定义时就�{�于�W�二句话�?nbsp;

但二句话无论是否定义了UNICODE都是生成一个ANSI字符�Ԍ��而第三句话��L��生成UNICODE字符丌Ӏ?/p>
��Z��E�序的可�U�L��性，��都用�W�一�U�表�C�方法�?/p>
但在某些情况下，某个字符必须为ANSI或UNICODE�Q�那��q��后两�U�方�?br>

      char :单字节变量类型，最多表�C?56个字�W?/p>
      wchar_t :宽字节变量类型，用于表示Unicode字符

      它实际定义在里：typedef unsigned short wchar_t�?/p>
      ��Z��让编译器识别Unicode字符�Ԍ��必须以在前面加一�?#8220;L”,定义宽字节类型方法如下：

     wchar_t c = `A' ;
     wchar_t * p = L"Hello!" ;
     wchar_t a[] = L"Hello!" ;

     其中�Q�宽字节�c�d��每个变量占用2个字节，故上�q�数�l�a的sizeof(a) = 14

     TCHAR / _T( ) :
      如果在程序中既包括ANSI又包括Unicode�~�码�Q�需要包括头文�gtchar.h。TCHAR是定义在该头文�g中的宏，它视你是否定义了
     NICODE宏而定义成�Q?
定义了_UNICODE�Q?nbsp;   typedef wchar_t TCHAR ;
没有定义_UNICODE�Q?typedef char TCHAR ;

#ifdef UNICODE
typedef char TCHAR;
#else
typede wchar_t TCHAR;
#endif
_T( )也是定义在该头文件中的宏�Q�视是否定义了_UNICODE宏而定义成�Q?
定义了_UNICODE�Q?nbsp;   #define _T(x) L##x
没有定义_UNICODE�Q?#define _T(x) x
注意�Q�如果在�E�序中��用了TCHAR�Q�那么就不应该��用ANSI的strXXX函数或者Unicode的wcsXXX函数了，而必��M��用tchar.h中定义的_tcsXXX函数�?/p>
以strcpy函数��Z��子，�ȝ��一下：

//如果你想使用ANSI字符�Ԍ��那么请��用这一套写法：
char szString[100];
strcpy(szString,"test");
//如果你想使用Unicode字符�Ԍ��那么请��用这一套：
wchar_t szString[100];
wcscpy(szString,L"test");
//如果你想通过定义_UNICODE宏，而编译ANSI或者Unicode字符串代码：
TCHAR szString[100];
_tcscpy(szString,_TEXT("test"));

char是C语言标准数据�c�d��Q�字�W�型�Q�至于由几个字节�l�成通常��q��译器军_��Q�一般一个字节。Windows��Z��消除�?�~�译器的差别�Q�重新定义了一些数据类型，你提��C��另外几个�c�d��都是�q�样�?br>CHAR为单字节字符�?br>�q�有个WCHAR为Unicode字符�Q�即不论中英文，�?个字有两个字节组成�?br>如果当前�~�译方式为ANSI(默认)方式�Q�TCHAR�{��h于CHAR�Q?br>如果为Unicode方式�Q�TCHAR�{��h于WCHAR�?br>在当前版本LPCSTR和LPSTR没区别，即以零结��字符串指针，相当于CHAR *�?br>

char :单字节变量类型，最多表�C?56个字�W�，

wchar_t :宽字节变量类型，用于表示Unicode字符�Q?/p>
它实际定义在里：typedef unsigned short wchar_t�?/p>
��Z��让编译器识别Unicode字符�Ԍ��必须以在前面加一�?#8220;L”,定义宽字节类型方法如下：

    wchar_t c = `A' ;
wchar_t * p = L"Hello!" ;
wchar_t a[] = L"Hello!" ;

其中�Q�宽字节�c�d��每个变量占用2个字节，故上�q�数�l�a的sizeof(a) = 14

TCHAR / _T( ) :
如果在程序中既包括ANSI又包括Unicode�~�码�Q�需要包括头文�gtchar.h。TCHAR是定义在该头文�g中的宏，它视你是否定义了_UNICODE宏而定义成�Q?
定义了_UNICODE�Q?nbsp;   typedef wchar_t TCHAR ;
没有定义_UNICODE�Q?typedef char TCHAR ;

#ifdef UNICODE
typedef char TCHAR;
#else
typede wchar_t TCHAR;
#endif
_T( )也是定义在该头文件中的宏�Q�视是否定义了_UNICODE宏而定义成�Q?
定义了_UNICODE�Q?nbsp;   #define _T(x) L##x
没有定义_UNICODE�Q?#define _T(x) x
注意�Q�如果在�E�序中��用了TCHAR�Q�那么就不应该��用ANSI的strXXX函数或者Unicode的wcsXXX函数了，而必��M��用tchar.h中定义的_tcsXXX函数�?/p>
以strcpy函数��Z��子，�ȝ��一下：

//如果你想使用ANSI字符�Ԍ��那么请��用这一套写法：
char szString[100];
strcpy(szString,"test");
//如果你想使用Unicode字符�Ԍ��那么请��用这一套：
wchar_t szString[100];
wcscpy(szString,L"test");
//如果你想通过定义_UNICODE宏，而编译ANSI或者Unicode字符串代码：
TCHAR szString[100];
_tcscpy(szString,_TEXT("test"));

CSDN:superarhow��_�� 不要再��用TCHAR和_T了！他分析了原因后�ȝ��Q�如果您正开始一个新的项目，��h��论如何也要顶住压力，直接使用UNICODE�~�码�Q�切讎ͼ�您只需要对您的�l�员�q�行10分钟的培训，��C��strcpy�?wcscpy�Q�sprintf用swprintf代替�Q�常数前加L�Q�就可以了！它不会花您很多时间的�Q�带�l�您的是�E�_��和安全！�怿��Ӟ��没错的！�Q?/p>
一�?在字�W�串前加一个L作用:
   �?nbsp; L"我的字符�?    表示��ANSI字符串�{换成unicode的字�W�串�Q�就是每个字�W�占用两个字节�?
strlen("asd")   =   3;
strlen(L"asd")   =   6;
二�?nbsp; _T宏可以把一个引号引��h��的字�W�串�Q�根据你的环境设�|�，使得�~�译器会�Ҏ��~�译目标环境选择合适的�Q�Unicode�q�是ANSI�Q�字�W�处理方�?
   如果你定义了UNICODE�Q�那么_T宏会把字�W�串前面加一个L。这�?_T("ABCD") 相当�?L"ABCD" �Q�这是宽字符丌Ӏ?
   如果没有定义�Q�那么_T宏不会在字符串前面加那个L�Q�_T("ABCD") ��q��价于 "ABCD"
三、TEXT,_TEXT 和_T 一��L��
如下面三语句�Q?nbsp;
TCHAR   szStr1[]   =   TEXT("str1");
char   szStr2[]   =   "str2";
WCHAR   szStr3[]   =   L("str3");
那么�W�一句话在定义了UNICODE时会解释为第三句话，没有定义时就�{�于�W�二句话�?nbsp;
但二句话无论是否定义了UNICODE都是生成一个ANSI字符�Ԍ��而第三句话��L��生成UNICODE字符丌Ӏ?nbsp;
��Z��E�序的可�U�L��性，��都用�W�一�U�表�C�方法�?nbsp;
但在某些情况下，某个字符必须为ANSI或UNICODE�Q�那��q��后两�U�方法�?/p>
CSDN:superarhow��_�� 不要再��用TCHAR和_T了！他分析了原因后�ȝ��Q�如果您正开始一个新的项目，��h��论如何也要顶住压力，直接使用UNICODE�~�码�Q�切讎ͼ�您只需要对您的�l�员�q�行10分钟的培训，��C��strcpy�?wcscpy�Q�sprintf用swprintf代替�Q�常数前加L�Q�就可以了！它不会花您很多时间的�Q�带�l�您的是�E�_��和安全！�怿��Ӟ��没错的！�Q?/p>

心羽 2010-08-23 16:46 发表评论

#ifndef#define#endif的用�?整理) (转发)

心羽 — Mon, 23 Aug 2010 02:47:00 GMT

[转] #ifndef#define#endif的用�?整理)    �?span class=addtime>作者：icwk

文�g中的#ifndef
头�g的中�?ifndef�Q�这是一个很关键的东�ѝ��比如你有两个C文�g�Q�这两个C文�g都include了同一个头文�g。而编译时�Q�这两个C文�g要一同编译成一个可�q�行文�g�Q�于是问题来了，大量的声明冲�H��?

�q�是把头文�g的内定w��攑֜�#ifndef�?endif中吧。不��你的头文�g会不会被多个文�g引用�Q�你都要加上�q�个。一般格式是�q�样的：

#ifndef <标识>
#define <标识>

......
......

#endif

<标识>在理��Z��来说可以是自由命名的�Q�但每个头文件的�q�个“标识”都应该是唯一的。标识的命名规则一般是头文件名全大写，前后加下划线�Q��ƈ把文件名中的“.”也变成下划线�Q�如�Q�stdio.h

#ifndef _STDIO_H_
#define _STDIO_H_

......

#endif

2.�?ifndef中定义变量出现的问题�Q�一般不定义�?ifndef中）�?/p>
#ifndef AAA
#define AAA
...
int i;
...
#endif
里面有一个变量定�?br>在vc中链接时��出��C��i重复定义的错误，而在c中成功编译�?/p>
�l�论�Q?/p>
(1).当你�W�一个��用这个头�?cpp文�g生成.obj的时候，int i 在里面定义了当另外一个��用这个的.cpp再次[单独]生成.obj的时候，int i 又被定义然后两个obj被另外一�?cpp也include �q�个头的�Q�连接在一��P��׃��出现重复定义.

(2).把源�E�序文�g扩展名改�?c后，VC按照C语言的语法对源程序进行编译，而不是C++。在C语言中，若是遇到多个int i�Q�则自动认�ؓ其中一个是定义�Q�其他的是声明�?/p>
(3).C语言和C++语言�q�接�l�果不同�Q�可能（猜测�Q�时在进行编译的时候，C++语言��全局
变量默认为强�W�号�Q�所以连接出错。C语言则依照是否初始化�q�行强弱的判断的。（参考）

解决�Ҏ��Q?/p>
(1).把源�E�序文�g扩展名改�?c�?/p>
(2).推荐解决�Ҏ��Q?br>.h中只声明 extern int i;�?cpp中定�?/p>

#ifndef __X_H__
#define __X_H__
extern int i;
#endif //__X_H__

int i;

注意问题�Q?/p>
(1).变量一般不要定义在.h文�g中�?/p>

-------------------------------------------------------------------------------------------------------------------------------------------

一般情况下�Q�源�E�序中所有的行都参加�~�译。但是有时希望对其中一部分内容只在满��一定条件才�q�行�~�译�Q�也��是对一部分内容指定�~�译的条�Ӟ��q�就�?#8220;条�g�~�译”。有�Ӟ��希望当满��x��条�g时对一�l�语句进行编译，而当条�g不满��x��则编译另一�l�语句�?
条�g�~�译命��o最常见的�Ş式�ؓ�Q?
    #ifdef 标识�W?
    �E�序�D?
    #else
    �E�序�D?
    #endif

    它的作用是：当标识符已经被定义过(一般是�?define命��o定义)�Q�则对程序段1�q�行�~�译�Q�否则编译程序段2�?
    其中#else部分也可以没有，卻I��
    #ifdef
    �E�序�D?
    #denif

    �q�里�?#8220;�E�序�D?#8221;可以是语句组�Q�也可以是命令行。这�U�条件编译可以提高C源程序的通用性。如果一个C源程序在不同计算机系�l�上�pȝ��上运行，而不同的计算机又有一定的差异。例如，我们有一个数据类型，在Windows�q�_��中，应该使用long�c�d��表示�Q�而在其他�q�_��应该使用float表示�Q�这样往往需要对源程序作必要的修改，�q�就降低了程序的通用性。可以用以下的条件编译：
    #ifdef WINDOWS
    #define MYTYPE long
    #else
    #define MYTYPE float
    #endif

    如果在Windows上编译程序，则可以在�E�序的开始加�?
    #define WINDOWS

    �q�样则编译下面的命��o行：
    #define MYTYPE long

    如果在这�l�条件编译命令之前曾出现以下命��o行：
    #define WINDOWS 0

    则预�~�译后程序中的MYTYPE都用float代替。这��P��源程序可以不必作��M��修改��可以用于不同类型的计算机系�l�。当然以上介�l�的只是一�U�简单的情况�Q�可以根据此思�\设计出其它的条�g�~�译�?
    例如�Q�在调试�E�序�Ӟ��常常希望输出一些所需的信息，而在调试完成后不再输��些信息。可以在源程序中插入以下的条件编译段�Q?
    #ifdef DEBUG
    print ("device_open(%p) ", file);
    #endif

    如果在它的前面有以下命��o行：
    #define DEBUG

    则在�E�序�q�行时输出file指针的��|��以便调试分析。调试完成后只需��这个define命��o行删除即可。有人可能觉得不用条件编译也可达此目的，卛_��调试时加一批printf语句�Q�调试后一一��printf语句删除厅R��的��，�q�是可以的。但是，当调试时加的printf语句比较多时�Q�修改的工作量是很大的。用条�g�~�译�Q�则不必一一删改printf语句�Q�只需删除前面的一�?#8220;#define DEBUG”命��o卛_��Q�这时所有的用DEBUG作标识符的条件编译段都��其中的printf语句不�v作用�Q�即��L��一控制的作用，如同一�?#8220;开�?#8221;一栗��?
    有时也采用下面的形式�Q?
    #ifndef 标识�W?
    �E�序�D?
    #else
    �E�序�D?
    #endif

    只是�W�一行与�W�一�U��Ş式不同：��?#8220;ifdef”改�ؓ“ifndef”。它的作用是�Q�若标识�W�未被定义则�~�译�E�序�D?�Q�否则编译程序段2。这�U��Ş式与�W�一�U��Ş式的作用相反�?
    以上两种形式用法差不多，�Ҏ��需要�Q选一�U�，视方便而定�?
    �q�有一�U��Ş式，��是#if后面的是一个表辑ּ��Q�而不是一个简单的标识�W�：
    #if 表达�?
    �E�序�D?
    #else
    �E�序�D?
    #endif

    它的作用是：当指定的表达式��gؓ真（非零�Q�时��q��译程序段1�Q�否则编译程序段2。可以事先给定一定条�Ӟ��使程序在不同的条件下执行不同的功能�?/p>
---------------------------------------------------------------------------------------------------------------------------------------

作用范围��是当前文�g啊。因为编译是以cpp或c文�g位单位的嘛。还以这个�ؓ例：

//正常代码
#ifdef _DEBUG
     TRACE("Some infomation");
#else
     //Now is release version,so do nothing
#endif
//正常代码

�~�译时是先把所有的预编译处理展开�Q�比如宏�Q�再�~�译�Q�所以Debug模式下，�~�译时的代码是：
//正常代码
TRACE("Some infomation");
//正常代码

Release模式下的代码是：
//正常代码
//正常代码
��Z��避免同一个文件被include多次

1   #ifndef方式
2   #pragma once方式

在能够支持这两种方式的编译器上，二者�ƈ没有太大的区别，但是两者仍然还是有一些细微的区别�?br>    方式一�Q?/span>
    #ifndef __SOMEFILE_H__
    #define __SOMEFILE_H__
    ... ... // 一些声明语�?br>    #endif

    方式二：

    #pragma once
    ... ... // 一些声明语�?/p>

    #ifndef的方式依赖于宏名字不能冲�H�，�q�不光可以保证同一个文件不会被包含多次�Q�也能保证内容完全相同的两个文�g不会被不��心同时包含。当�Ӟ��~�点��是如果不同头文件的宏名不小�?#8220;撞�R”�Q�可能就会导致头文�g明明存在�Q�编译器却硬说找不到声明的状�?br>
    #pragma once则由�~�译器提供保证：同一个文件不会被包含多次。注意这里所说的“同一个文�?#8221;是指物理上的一个文�Ӟ��而不是指内容相同的两个文件。带来的好处是，你不必再费劲想个宏名了，当然也就不会出现宏名��撞引发的奇怪问题。对应的�~�点��是如果某个头文件有多䆾拯��Q�本�Ҏ��不能保证他们不被重复包含。当�Ӟ��相比宏名��撞引发�?#8220;找不到声�?#8221;的问题，重复包含更容易被发现�q�修正�?br>
   方式一��p��a�支持所以移植性好�Q�方式二可以避免名字冲突

心羽 2010-08-23 10:47 发表评论

C++中const用法�ȝ��(转发)

心羽 — Mon, 23 Aug 2010 02:42:00 GMT

作者JuKevin
1. const修饰普通变量和指针

const修饰变量�Q�一般有两种写法�Q?
const TYPE value;
TYPE const value;
�q�两�U�写法在本质上是一��L��。它的含义是�Q�const修饰的类型�ؓTYPE的变量value是不可变的�?
对于一个非指针的类型TYPE�Q�无论怎么写，都是一个含义，即value只不可变�?
例如�Q?
const int nValue�Q?        //nValue是const
int const nValue�Q?nbsp;   // nValue是const
但是对于指针�c�d��的TYPE�Q�不同的写法会有不同情况�Q�例如：
A. const char *pContent;
B. char * const pContent;
C. char const *pContent;
D. const char* const pContent;

对于前三�U�写法，我们可以换个方式�Q�给其加上括�?
A. const (char) *pContent;
B. (char*) const pContent;
C. (char) const *pContent;
�q�样��׃��目了然。根据对于const修饰非指针变量的规则�Q�很明显�Q�A=C.

- 对于A,C, const修饰的类型�ؓchar的变�?pContent为常量，因此�Q�pContent的内容�ؓ帔R��不可�?
- 对于B, const修饰的类型�ؓchar*的变量pContent为常量，因此�Q�pContent指针本��n为常量不可变.
- 对于D, 其实是A和B的�؜合体�Q�表�C�指针本�w�和指针内容两者皆为常量不可变

�ȝ��:
(1) 指针本��n是常量不可变
(char*) const pContent;

(2) 指针所指向的内�Ҏ��帔R��不可�?
const (char) *pContent;
(char) const *pContent;

(3) 两者都不可�?
const char* const pContent;

�q�有其中区别�Ҏ��Q?
沿着*号划一条线�Q?
如果const位于*的左侧，则const��是用来修饰指针所指向的内容变量，��x��针指向�ؓ帔R��Q�物帔R��Q�；
如果const位于*的右侧，const��是修饰指针本��n�Q�即指针本��n是常量（指针帔R��Q��?/span>

��例子：
char ch[5] = "lisi";
const char* pStr = ch;
*pStr = 'w'; //error�Q�物帔R��Q�不可更改内�?br>pStr ="wangwu"; //OK�Q�物帔R��Q�可更改指针

cha ch[5] = "lisi";
char * const pStr = "lisi";
pStr = "zhangsan"; //error�Q�指针常量，不可更改指针
*pStr = "w"; //OK �Q�指针常量，可更改内�?
2. const修饰函数参数

const修饰函数参数是它最�q�泛的一�U�用途，它表�C�函��C��中不能修改参数的�?包括参数本��n的值或者参数其中包含的�?。它可以很好

void function(const int Var); //传递过来的参数在函数内不可以改�?无意义，因�ؓVar本��n��是形参)
void function(const char* Var); //参数指针所指内容�ؓ帔R��不可�?
void function(char* const Var); //参数指针本��n为常量不可变(也无意义�Q?因�ؓchar* Var也是形参)

参数为引用，��Z��增加效率同时防止修改�?
修饰引用参数�Ӟ��
void function(const Class& Var);//引用参数在函数内不可以改�?
void function(const TYPE& Var); //引用参数在函数内为常量不可变

3. const 修饰函数�q�回�?/p>
const修饰函数�q�回值其实用的�ƈ不是很多�Q�它的含义和const修饰普通变量以及指针的含义基本相同�?
(1) const int fun1() �q�个其实无意义，因�ؓ参数�q�回本��n��是赋倹{�?
(2) const int * fun2()
调用�?const int *pValue = fun2();
我们可以把fun2()看作成一个变量，那么��是我们上面所说的1.(1)的写法，��x��针内容不可变�?
(3) int* const fun3()
调用�?int * const pValue = fun2();
我们可以把fun2()看作成一个变量，那么��是我们上面所说的1.(2)的写法，��x��针本�w�不可变�?
4. const修饰�c�d��?对象指针/对象引用

const修饰�c�d��象表�C��对象为常量对象，其中的�Q何成员都不能被修攏V��对于对象指针和对象引用也是一栗��?
const修饰的对象，该对象的��M��非const成员函数都不能被调用�Q�因��Z�Q何非const成员函数会有修改成员变量的企图�?
例如�Q?
class AAA
{
   void func1();
void func2() const;
}
const AAA aObj;
aObj.func1(); ×
aObj.func2(); 正确

const AAA* aObj = new AAA();
aObj->func1(); ×
aObj->func2(); 正确

5. const修饰成员变量

const修饰�cȝ��成员函数�Q�表�C�成员常量，不能被修改，同时它只能在初始化列表中赋倹{�?

class A
{
   …
   const int nValue;       //成员帔R��不能被修�?
   …
   A(int x): nValue(x) {}; //只能在初始化列表中赋�?
}

6. const修饰成员函数

const修饰�cȝ��成员函数�Q�则该成员函��C��能修改类中�Q何非const成员函数。一般写在函数的最后来修饰�?

class A
{
   …
void function()const; //常成员函�? 它不改变对象的成员变�? 也不能调用类中�Q何非const成员函数�?
}
对于const�c�d��?指针/引用�Q�只能调用类的const成员函数�Q�因此，const修饰成员函数的最重要作用��是限制对于const对象的��用�?

7. const帔R��与define宏定义的区别

(1) �~�译器处理方式不�?
define宏是在预处理阶段展开�?
const帔R��是编译运行阶�D��用�?
(2) �c�d��和安全检查不�?
define宏没有类型，不做��M��c�d��查，仅仅是展开�?
const帔R��有具体的�c�d��Q�在�~�译阶段会执行类型检查�?
(3) 存储方式不同
define宏仅仅是展开�Q�有多少地方使用�Q�就展开多少�ơ，不会分配内存�?
const帔R��会在内存中分�?可以是堆中也可以是栈�?�?/p>

心羽 2010-08-23 10:42 发表评论

心羽 — Mon, 23 Aug 2010 02:17:00 GMT
用例子给你示�?
// 1.cpp
int x = 10;
// 2.cpp 注意没有包含1.cpp
#include
using namespace std;
extern int x;
int main ()
{ cout << x << endl; }
//则输�?0
两个文�g同在一个项目（project�Q�中�Q�你不包含某个文�Ӟ��cpp�Q�而可以用它内部定义的变量�Q?�q�里�?cpp不是.h, 因�ؓ�?h中定义的数据不能�?cpp中用除非�q�个.cpp包含�q�个.h文�g�Q?/span>
例：
// 1.h
#include
void print()
{
std::cout << "hello!" << std::endl;
}
// 2.cpp
#include
using namespace std;
// 以上两句在这个例子中可以不要
extern void print();
int main ()
{
print();
}
��׃��出错因�ؓ1.h中的void print()�Q�在不包含它的文件中是不可调用的�Q�即使在声明了extern 也于事无补，如果你将�q�个例子中的1.h名字换成1.cpp��对了！
从这些可以看出来�Q�extern在这里�v的作用是告诉�~�译器，你这个print()已经在某�?cpp中已�l�定义了�Q�这里只不过是声明一下有�q�个东西�Q�然后拿来用一下。定义只能出��C��ơ，声明却可出现多次�Q�也��是说extern声明可在多个文�g中用�Q�包�?h)
�q�有�Q�你�q�可以屏蔽extern声明�Q�如�W�二个例子中的第二个.cpp文�g可以�Ҏ��
#include
using namespace std;
// �q�里以上两句不能省略�Q�因为，�q�里extern void print();函数已经不�v作用了，在这里调用的而是本文件中定义的void print()函数�Q�其中用��C��cout,endl;他们来源于std::
extern void print();
void print()
{
cout << "world!" << endl;
}

int main ()
{
print();
}
// 输出�l�果为world!
�q�有一个extern "C"��׃��用说了，用这个可以允许C++�E�序中调用C的函敎ͼ�

心羽 2010-08-23 10:17 发表评论

C/C++/VC随机数�ȝ��

心羽 — Sun, 02 May 2010 03:10:00 GMT

大家都知道C语言中的随机函数random�Q�可是random函数�q�不是ANSI C标准�Q�所以说�Q�random函数不能在gcc,vc�{�编译器下编
译通过。那么怎么实现VC语言中的随机函数呢？

其实�Q�除了random函数�Q�还有一个rand函数�Q�这个函��C��是一个随机函敎ͼ�他可以��生从0到rand_max(32767)的随机数�?/p>

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

int main()
{
   int k;
   k = rand();
   printf("%d\\n", k);
   return 0;
}//main

大家可以把以上的代码�~�译�q�行一下，发现他的��生随机数了，但是你会发现�Q�每�ơ运行程序��生的随机数都是一��L��Q�不�q�你在程序里加上for循环�Q�每�ơ��生的��C��一��P��但是�Q�如果再�q�行�q�个�E�序�Q�它产生的数据却都是相同的�?/p>
那么如何写一个程序，让它每次�q�行时��生的随机数都不一样呢�Q?��L��下面的例子：

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include<iostream>
using namespace std;
int main(void)
{
   int i;
   time_t t;
   srand((unsigned) time(&t));
  cout<<"Ten random numbers from 0 to 99\n\n";
   for(i=0; i<10; i++)
       printf("%d\n", rand() % 100);
   return 0;
}

�q�时�q�行�E�序�Q�会发现每次产生的随机数都不一栗��?/p>
那么��Z��么第一个程序一栯��第二个�E�序一样呢�Q?/p>
�W�二个程序用��C��一个新的函数srand

�q�个函数是给随机��C�生一个随机种�?seed)�Q�函数原型是srand( (unsigned)time( NULL ) );

time的值每时每刻都不同。所以种子不同，所以，产生的随机数也不同�?/p>
所以说�Q�要想��生不同的随机敎ͼ�在��用rand之前需要先调用srand

srand和rand函数都包含在stdlib.h的头文�g里�?/p>
�׃��rand产生的随机数是从0到rand_max的，而rand_max�Q?2767�Q�是一个很大的敎ͼ�那么如何产生从X~Y的数呢？

从X到Y�Q�有Y�Q�X�Q?个数�Q�所以要产生从X到Y的数�Q�只需要这样写�Q?/p>
k = rand() % (Y - X + 1) +X;

�q�样�Q�就可以产生你想要的��M��范围内的随机��C��?
问题�Q�如何生成K个小于Ｎ�q�且互不重复的整�?/span>

一.首先对于c++的随机函数我们要有所了解�Q�这里就不篏赘了�Q�请读者自行google之，
我们要用到的�?br>1. void srand(unsigned int_seed)函数产生一个以当前旉��开始的随机�U�子
  srand(unsigned(time(NULL))),必须攑֜�生成随机数前
2.int rand()函数�Q�随��Z�生一整数
   rand()%MAX 产生[0,MAX)的整�?br>   a+rand()%(b-a+1) 产生[a,b]之间的整�?br>3.需要头文�g#include

#include<iostream>
using namespace std;
#include<time.h>
#define N 100
#define K 20

int x[N];
void swap(int i,int j)
{
  int temp=x[i];
  x[i]=x[j];
  x[j]=temp;
}
int main()
{
    int i;
    for(i=0;i<N;i++)
        x[i]=i;
    srand(unsigned(time(NULL)));
    for(i=0;i<K;i++){
        swap(i,i+rand()%(N-i));
        cout<<x[i]<<" ";
    }

    return 0;
}

�?考虑如何让数据不重复
看代码吧。。学习下�Ҏ��
首先搞个一�l�没有重复数据的数组�Q�就是x[i]=i;
此时注意那个swap函数�Q�每�ơ生成的随机��C��为数�l�下标去取数�Q�然后交换，�q�就保证了x�q�个数组�l�不会有重复的数出现�?br>�l�了�Q�！

心羽 2010-05-02 11:10 发表评论

C语言全��d��W�串函数

心羽 — Sat, 24 Apr 2010 18:07:00 GMT
~对初学者属于深入理解吧�Q�高手请勿在此浪费宝贉|��间~

看到�q�样一个改错题�Q?br>
char p[5];
char* s="12345";
strcpy(p,s);
   cout << p << endl;
错误之处是很昄��的，作�ؓ字符串字面值的"12345"会在�l�尾处自动加上空字符null�Q�从而长度是6�Q�上面的strcpy是会��界的，从而是个越界错误�?br>问题是我以�ؓ�q�样的程序编译的时候会出错�?但是我在vc上运行时是可以输出正��结果的�Q�这让我很是�U�闷�Q�后来找��C��strcpy的源代码才知原因�Q�strcpy函数是不�q�行��界处理�? 又因为strcpy�q�null一起复�Ӟ��从而p能输出正��的�l�果"12345"
/**//*The strcpy function copies strSource, including the terminating null character, to the location specified by strDestination. No overflow checking is performed when strings are copied or appended. The behavior of strcpy is undefined if the source and destination strings overlap.*/
char * __cdecl strcpy(char * dst, const char * src)
{
char * cp = dst;

while( *cp++ = *src++ )
; /**//* Copy src over dst */

return( dst );
}
貌似strcpy虽然不进行越界处理，仍然是个挺好的函数呢�Q�但是注意了�Q�下面的代码��p��暴露出strcpy 的缺点了.

char p[5];
char *s = "12345678";
strcpy(p,s);
cout << p <<endl; //输出12345678�Q�而不是我们所设想�?2345
��Z��不因不知s的长度而犯下错误，推荐使用strncpy。但是是不是用了strncpy��׃��无一�׃��呢？看下面的代码�Q?br>
char p[5];
char* s = "12345";
strncpy(p,s,5);
cout << p <<endl; //12345*&^(后面表示��q��)
不是都限制个��C��么？��Z��么后面又有�ؕ码？
问题来自在上�q�情形strncpy是不会复制字�W�串s后面的null的，不是以null�l�束的p不会输出正确�l�果的�?br>仍然�l�出strncpy的源代码�Q?br>
/**//*The strncpy function copies the initial count characters of strSource to strDest and returns strDest. If count is less than or equal to the length of strSource, a null character is not appended automatically to the copied string. If count is greater than the length of strSource, the destination string is padded with null characters up to length count. The behavior of strncpy is undefined if the source and destination strings overlap.*/
char * __cdecl strncpy ( char * dest, const char * source, size_t count )
{
char *start = dest;

while (count && (*dest++ = *source++)) /**//* copy string */
count--;

if (count) /**//* pad out with zeroes */
while (--count)
*dest++ = '\0';

return(start);
}
那strncpy�q�么不稳定，��Z��用它�Q�strncpy�l�常用于修改一个长字符串中间的一部分�Q�看��Z��复制null的原因了吧！�Q�，如果实在要用��C��q�的代码上，��在代码最后加上p[5] = '\0'; 吧！

函数�? stpcpy
�?nbsp; �? 拯��一个字�W�串到另一�?
�?nbsp; �? char *stpcpy(char *destin, char *source);
�E�序�?
#include
#include
int main(void)
{
   char string[10];
   char *str1 = "abcdefghi";
   stpcpy(string, str1);
   printf("%sn", string);
   return 0;
}

函数�? strcat
�?nbsp; �? 字符串拼接函�?
�?nbsp; �? char *strcat(char *destin, char *source);
�E�序�?
#include
#include
int main(void)
{
   char destination[25];
   char *blank = " ", *c = "C++", *Borland = "Borland";
   strcpy(destination, Borland);
   strcat(destination, blank);
   strcat(destination, c);
   printf("%sn", destination);
   return 0;
}

函数�? strchr
�?nbsp; �? 在一个串中查扄��定字�W�的�W�一个匹配之�?
�?nbsp; �? char *strchr(char *str, char c);
�E�序�?
#include
#include
int main(void)
{
    char string[15];
    char *ptr, c = 'r';
    strcpy(string, "This is a string");
    ptr = strchr(string, c);
    if (ptr)
       printf("The character %c is at position: %d\n", c, ptr-string);// 不明�?nbsp;
    else
       printf("The character was not foundn");
    return 0;
}

函数�? strcmp
�?nbsp; �? 串比�?
�?nbsp; �? int strcmp(char *str1, char *str2);
看Asic码，str1>str2�Q�返回�?> 0�Q�两串相�{�，�q�回0
�E�序�?
#include
#include
int main(void)
{
    char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";
    int ptr;
    ptr = strcmp(buf2, buf1);
    if (ptr > 0)
       printf("buffer 2 is greater than buffer 1n");
    else
       printf("buffer 2 is less than buffer 1n");
    ptr = strcmp(buf2, buf3);
    if (ptr > 0)
       printf("buffer 2 is greater than buffer 3n");
    else
       printf("buffer 2 is less than buffer 3n");
    return 0;
}

函数�? strncmpi
�?nbsp; �? ��一个串中的一部分与另一个串比较, 不管大小�?
�?nbsp; �? int strncmpi(char *str1, char *str2, unsigned maxlen);
�E�序�?
#include
#include
int main(void)
{
   char *buf1 = "BBB", *buf2 = "bbb";
   int ptr;
   ptr = strcmpi(buf2, buf1);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1n");
   if (ptr < 0)
      printf("buffer 2 is less than buffer 1n");
   if (ptr == 0)
      printf("buffer 2 equals buffer 1n");
   return 0;
}

函数�? strcpy
�?nbsp; �? 串拷�?
�?nbsp; �? char *strcpy(char *str1, char *str2);
�E�序�?
#include
#include
int main(void)
{
    char string[10];
    char *str1 = "abcdefghi";
    strcpy(string, str1);
    printf("%sn", string);
    return 0;
}

函数�? strcspn
�?nbsp; �? 在串中查扄��一个给定字�W�集内容的段
�?nbsp; �? int strcspn(char *str1, char *str2);
�E�序�?
#include
#include
#include
int main(void)
{
    char *string1 = "1234567890";
    char *string2 = "747DC8";
    int length;
    length = strcspn(string1, string2);
    printf("Character where strings intersect is at position %dn", length);
    return 0;
}

函数�? strdup
�?nbsp; �? ��串拯��到新建的位置�?
�?nbsp; �? char *strdup(char *str);
�E�序�?
#include
#include
#include
int main(void)
{
    char *dup_str, *string = "abcde";
    dup_str = strdup(string);
    printf("%sn", dup_str);
    free(dup_str);
    return 0;
}

函数�? stricmp
�?nbsp; �? 以大��写不敏感方式比较两个串
�?nbsp; �? int stricmp(char *str1, char *str2);
�E�序�?
#include
#include
int main(void)
{
   char *buf1 = "BBB", *buf2 = "bbb";
   int ptr;
   ptr = stricmp(buf2, buf1);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1n");
   if (ptr < 0)
      printf("buffer 2 is less than buffer 1n");
   if (ptr == 0)
      printf("buffer 2 equals buffer 1n");
   return 0;
}

函数�? strerror
�?nbsp; �? �q�回指向错误信息字符串的指针
�?nbsp; �? char *strerror(int errnum);
�E�序�?
#include
#include
int main(void)
{
   char *buffer;
   buffer = strerror(errno);
   printf("Error: %sn", buffer);
   return 0;
}

函数�? strcmpi
�?nbsp; �? ��一个串与另一个比�? 不管大小�?
�?nbsp; �? int strcmpi(char *str1, char *str2);
�E�序�?
#include
#include
int main(void)
{
   char *buf1 = "BBB", *buf2 = "bbb";
   int ptr;
   ptr = strcmpi(buf2, buf1);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1n");
   if (ptr < 0)
      printf("buffer 2 is less than buffer 1n");
   if (ptr == 0)
      printf("buffer 2 equals buffer 1n");
   return 0;
}

函数�? strncmp
�?nbsp; �? 串比�?
�?nbsp; �? int strncmp(char *str1, char *str2, int maxlen);
�E�序�?
#include
#include
int main(void)
{
   char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc";
   int ptr;
   ptr = strncmp(buf2,buf1,3);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1n");
   else
      printf("buffer 2 is less than buffer 1n");
   ptr = strncmp(buf2,buf3,3);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 3n");
   else
      printf("buffer 2 is less than buffer 3n");
   return(0);
}

函数�? strncmpi
�?nbsp; �? 把串中的一部分与另一串中的一部分比较, 不管大小�?
�?nbsp; �? int strncmpi(char *str1, char *str2);
�E�序�?
#include
#include
int main(void)
{
   char *buf1 = "BBBccc", *buf2 = "bbbccc";
   int ptr;
   ptr = strncmpi(buf2,buf1,3);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1n");
   if (ptr < 0)
      printf("buffer 2 is less than buffer 1n");
   if (ptr == 0)
      printf("buffer 2 equals buffer 1n");
   return 0;
}

函数�? strncpy
�?nbsp; �? 串拷�?
�?nbsp; �? char *strncpy(char *destin, char *source, int maxlen);
�E�序�?
#include
#include
int main(void)
{
   char string[10];
   char *str1 = "abcdefghi";
   strncpy(string, str1, 3);
   string[3] = '';
   printf("%sn", string);
   return 0;
}

函数�? strnicmp
�?nbsp; �? 不注重大��写地比较两个串
�?nbsp; �? int strnicmp(char *str1, char *str2, unsigned maxlen);
�E�序�?
#include
#include
int main(void)
{
   char *buf1 = "BBBccc", *buf2 = "bbbccc";
   int ptr;
   ptr = strnicmp(buf2, buf1, 3);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1n");
   if (ptr < 0)
      printf("buffer 2 is less than buffer 1n");
   if (ptr == 0)
      printf("buffer 2 equals buffer 1n");
   return 0;
}

函数�? strnset
�?nbsp; �? ��一个串中的所有字�W�都设�ؓ指定字符
�?nbsp; �? char *strnset(char *str, char ch, unsigned n);
�E�序�?
#include
#include
int main(void)
{
   char *string = "abcdefghijklmnopqrstuvwxyz";
   char letter = 'x';
   printf("string before strnset: %sn", string);
   strnset(string, letter, 13);
   printf("string after strnset: %sn", string);
   return 0;
}

函数�? strpbrk
�?nbsp; �? 在串中查扄��定字�W�集中的字符
�?nbsp; �? char *strpbrk(char *str1, char *str2);
�E�序�?
#include
#include
int main(void)
{
   char *string1 = "abcdefghijklmnopqrstuvwxyz";
   char *string2 = "onm";
   char *ptr;
   ptr = strpbrk(string1, string2);
   if (ptr)
      printf("strpbrk found first character: %cn", *ptr);
   else
      printf("strpbrk didn't find character in setn");
   return 0;
}

函数�? strrchr
�?nbsp; �? 在串中查找指定字�W�的最后一个出�?
�?nbsp; �? char *strrchr(char *str, char c);
�E�序�?
#include
#include
int main(void)
{
   char string[15];
   char *ptr, c = 'r';
   strcpy(string, "This is a string");
   ptr = strrchr(string, c);
   if (ptr)
      printf("The character %c is at position: %dn", c, ptr-string);
   else
      printf("The character was not foundn");
   return 0;
}

函数�? strrev
�?nbsp; �? 串倒�{
�?nbsp; �? char *strrev(char *str);
�E�序�?
#include
#include
int main(void)
{
   char *forward = "string";
   printf("Before strrev(): %sn", forward);
   strrev(forward);
   printf("After strrev(): %sn", forward);
   return 0;
}

函数�? strset
�?nbsp; �? ��一个串中的所有字�W�都设�ؓ指定字符
�?nbsp; �? char *strset(char *str, char c);
�E�序�?
#include
#include
int main(void)
{
   char string[10] = "123456789";
   char symbol = 'c';
   printf("Before strset(): %sn", string);
   strset(string, symbol);
   printf("After strset(): %sn", string);
   return 0;
}

函数�? strspn
�?nbsp; �? 在串中查找指定字�W�集的子集的�W�一�ơ出�?
�?nbsp; �? int strspn(char *str1, char *str2);
�E�序�?
#include
#include
#include
int main(void)
{
   char *string1 = "1234567890";
   char *string2 = "123DC8";
   int length;
   length = strspn(string1, string2);
   printf("Character where strings differ is at position %dn", length);
   return 0;
}

函数�? strstr
�?nbsp; �? 在串中查找指定字�W�串的第一�ơ出�?
�?nbsp; �? char *strstr(char *str1, char *str2);
�E�序�?
#include
#include
int main(void)
{
   char *str1 = "Borland International", *str2 = "nation", *ptr;
   ptr = strstr(str1, str2);
   printf("The substring is: %sn", ptr);
   return 0;
}

函数�? strtod
�?nbsp; �? ��字�W�串转换为double型�?
�?nbsp; �? double strtod(char *str, char **endptr);
�E�序�?
#include
#include
int main(void)
{
   char input[80], *endptr;
   double value;
   printf("Enter a floating point number:");
   gets(input);
   value = strtod(input, &endptr);
   printf("The string is %s the number is %lfn", input, value);
   return 0;
}

函数�? strtok
�?nbsp; �? 查找由在�W�二个串中指定的分界�W�分隔开的单�?
�?nbsp; �? char *strtok(char *str1, char *str2);
�E�序�?
#include
#include
int main(void)
{
   char input[16] = "abc,d";
   char *p;
   /* strtok places a NULL terminator
   in front of the token, if found */
   p = strtok(input, ",");
   if (p)   printf("%sn", p);
   /* A second call to strtok using a NULL
   as the first parameter returns a pointer
   to the character following the token */
   p = strtok(NULL, ",");
   if (p)   printf("%sn", p);
   return 0;
}

函数�? strtol
�?nbsp; �? ��串转换为长整数
�?nbsp; �? long strtol(char *str, char **endptr, int base);
�E�序�?
#include
#include
int main(void)
{
   char *string = "87654321", *endptr;
   long lnumber;
   /* strtol converts string to long integer */
   lnumber = strtol(string, &endptr, 10);
   printf("string = %s long = %ldn", string, lnumber);
   return 0;
}

函数�? strupr
�?nbsp; �? ��串中的��写字母转换为大写字�?
�?nbsp; �? char *strupr(char *str);
�E�序�?
#include
#include
int main(void)
{
   char *string = "abcdefghijklmnopqrstuvwxyz", *ptr;
   /* converts string to upper case characters */
   ptr = strupr(string);
   printf("%sn", ptr);
   return 0;
}

函数�? swab
�?nbsp; �? 交换字节
�?nbsp; �? void swab (char *from, char *to, int nbytes);
�E�序�?
#include
#include
#include
char source[15] = "rFna koBlrna d";
char target[15];
int main(void)
{
   swab(source, target, strlen(source));
   printf("This is target: %sn", target);
   return 0;
}

PS:isalpha()是字�W�函敎ͼ�不是字符串函敎ͼ�

isalpha

原型�Q�extern int isalpha(int c);

用法�Q?include

功能�Q�判断字�W�c是否��文字�?br>
说明�Q�当c��文字母a-z或A-Z�Ӟ��q�回非零��|��否则�q�回�?/span>�?br>
举例�Q?br>
      // isalpha.c

      #include
      #include
      #include

      main()
      {
        int c;

        clrscr();        // clear screen
        printf("Press a key");
        for(;;)
        {
          c=getchar();
          clrscr();
          printf("%c: %s letter",c,isalpha(c)?"is":"not");
        }
        return 0; // just to avoid warnings by compiler
      }

心羽 2010-04-25 02:07 发表评论

午夜老司机精品,久久精品国产欧美激情,欧美视频一区二区三区在线观看

Datatype misalignment

C++关键字：mutable、volatile、explicit以及__based

�U�M��操作

Visual C++�~�程命名规则

#ifdef __cplusplus 学习

EVC�U�L��到VC�ȝ��

基本数据�c�d���Q�字�W�型�Q�上�Q?

_cdecl,_fastcall和_stdcall的区�?

【分享】C数组与指针学习笔�?

函数成员变量

static用法�ȝ��

零值比�?-BOOL�Q�int�Q�float�Q�指针变量与零值比较的if语句

C++高效�~�程忠告

#ifndef#define#endif的用�?整理) (转发)

C++中const用法�ȝ��(转发)

C/C++/VC随机数�ȝ��

C语言全��d���W�串函数

基本数据�c�d��Q�字�W�型�Q�上�Q?

C语言全��d��W�串函数