对于读取数据流时（如网络或文件）要特别注意。

比如

PBYTE pData;

//指向接收到的数据流

int * pi = pData + 这次接收到数据流的大小 - 4；

//指向接收到数据流的最后4位,可能客户端发过来的这个数据流最后4位是int，那样就是对齐好的了。也有可能不是int。

if *pi = 4561321  endparse data;//判断作为数据流的结束标志，最后4位的前面可能是全是char的。

由于这最后4位可能不是int，那样就有可能不对齐，这里就会出现Datatype misalignment错误。但是我们还是必须通过最后4位作为结束标志，而只有知道什么时候结束才能用int指针指向最后4位才不会出现对齐错误。这样形成了一个死循环，难道没办法解决了么？

PBYTE pData;

PBYTE * pi = pData + 这次接收到数据流的大小 - 4；

int i;

memcpy(&i, pi, 4);

if i = 4561321  endparse data;

这样就可以解决用int* pi指向未对齐的int错误了。

这一招对所有碰到Datatype misalignment的数据的访问应该都有效，就是把Datatype misalignment的数据用memcpy拷贝到对齐的内存来访问。

1，解析数据流时应该时刻注意。如果需要把一个数据流（BUFFER）转化成结构进行取值，就应该把这个结构定义为按字节存取.考虑如下结构：

struct a{

char a;
short b;
long c;
};
如果某个数据流中包含这样的结构，而且我们要直接将数据流的指针转化成该结构的指针，然后直接取结构成员的值，我们就应该将这个结构定义成按字节访问，即将其夹在语句
#pragma pack(push,1)//设为1字节对齐
...

#pragma pack(pop)//还原为原来的字节对齐方式
之中。如果我们不这样做，编译器会将成员b的地址对齐到short指针的地址，即在a之后加上一个char即8位的成员，将C对齐到LONG，即在B之后再加一个char成员。如此一来，成员B和成员C就得不到正确的值了。

pragma pack 只作用于结构的定义，而不是分配内存空间。把一个结构定义为pack1后，这个结构在程序中就一直是1了。

上面这个例子是客户端发送3个连续的数据不是发送结构体，服务端接收结构体。

如果客户端也发送结构体，服务端也接收结构体就不需要这样了。但是前提是双方的对齐方式一致。所以在客户端发送前也要用#pragma pack()一下，服务端也要#pragma pack()一下。

最好还是客户端也单个数据发送，服务端也单个数据接收。

如果我们定义一个普通的结构用来存放一些数据，则不用定义成按字节存取，编译器会加上一些占位成员，但并不会影响程序的运行。从这个意义上讲，在ARM中，将结构成员定义成CHAR和SHORT来节约内存是没有意义的。

一个典型的例子就文件系统的驱动程序，文件是以一些已经定义好的结构存放在存储介质上的，它们被读取到一个BUFFER中，而具体取某个文件、目录结构时，我们会将地址转化成结构而读取其中的值。

2，访问外设时。
例如，磁盘驱动通常以16BIT的方式存取数据，即每次存取两个字节，这样就要求传给它的BUFFER是双字节对齐的，驱动程序应该至上层传来的指针做出正确的处理以保证数据的正确性。

3.有时，我们没有将数据流指针转化为结构指针取值，但如果我们读取的是双字节或者是四字节的数据，同样需要注意对齐的问题，例如，如果从一个BUFFER的偏移10处读取一个四字节值，则实际得到的值是偏移8处的
地址上的DWORD值。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lqk1985/archive/2008/10/23/3129842.aspx

最近笔者一直在做JPEG的解码工作，发现用完全使用哈夫曼树进行解码比较费时，而使用表结构存储编码和值的对应关系比较快捷，但是也存在比较难处理的地方，比如解码工作通常是以位为单位的操作，这里必然会涉及到移位操作，而笔者之前对位的操作很少，经验很欠缺，经过这次历练终于发现了一个自己曾经忽视的东西，那就是C/C++中的移位操作容易出错的情况。

1、什么样的数据类型可以直接移位

char、short、int、long、unsigned char、unsigned short、unsigned int、unsigned long都可以进行移位操作，而double、float、bool、long double则不可以进行移位操作。

2、有符号数据类型的移位操作

对于char、short、int、long这些有符号的数据类型：

• 对负数进行左移：符号位始终为1，其他位左移
• 对正数进行左移：所有位左移，即 <<，可能会变成负数
• 对负数进行右移：取绝对值，然后右移，再取相反数
• 对正数进行右移：所有位右移，即 >>

3、无符号数据类型的移位操作

对于unsigned char、unsigned short、unsigned int、unsigned long这些无符号数据类型：

没有特殊要说明的，使用<< 和 >> 操作符就OK了

结束语

8086 中存在逻辑移位、算术移位，而C\C++中的移位似乎既不是逻辑移位，也不是算术移位。

比如-1，我们若对它右移1位，C的结果仍旧是-1，事实上无论右移多少位始终是-1，逻辑移位得到的结果（8位表示）应该是-128，所以这点要注意

例子：
1.将 13800138000  转为  91 68 31 08 10 83 00 F0  //91为+ 68国家号 不够位长以F补

二、命名规则：    
    1、变量名的命名规则    
    ①、变量的命名规则要求用“匈牙利法则”。即开头字母用变量的类型，其余部分用变量的英文意思或其英文意思的缩写,尽量避免用中文的拼音,要求单词的第一个字母应大写。    
    即：     变量名=变量类型+变量的英文意思（或缩写）    
    对非通用的变量，在定义时加入注释说明，变量定义尽量可能放在函数的开始处。    
    见下表：    
    bool(BOOL)     用b开头     bIsParent    
    byte(BYTE)     用by开头     byFlag    
    short(int)     用n开头     nStepCount    
    long(LONG)     用l开头     lSum    
    char(CHAR)     用c开头     cCount    
    float(FLOAT)     用f开头     fAvg    
    double(DOUBLE)     用d开头     dDeta    
    void(VOID)     用v开头     vVariant    
    unsigned     int（WORD）     用w开头     wCount    
    unsigned     long(DWORD)     用dw开头     dwBroad    
    HANDLE（HINSTANCE）     用h开头     hHandle    
    DWORD     用dw开头     dwWord    
    LPCSTR(LPCTSTR)     用str开头     strString    
    用0结尾的字符串     用sz开头     szFileName    
   
    对未给出的变量类型要求提出并给出命名建议给技术委员会。    
   
    ②、指针变量命名的基本原则为：    
    对一重指针变量的基本原则为：    
    “p”+变量类型前缀+命名    
    如一个float*型应该表示为pfStat    
    对多重指针变量的基本规则为：    
    二重指针：     “pp”+变量类型前缀+命名    
    三重指针：     “ppp”+变量类型前缀+命名    
    ......    
    ③、全局变量用g_开头,如一个全局的长型变量定义为g_lFailCount,即：变量名=g_+变量类型+变量的英文意思（或缩写）    
    ④、静态变量用s_开头,如一个静态的指针变量定义为s_plPerv_Inst,即：     变量名=s_+变量类型+变量的英文意思（或缩写）    
    ⑤、成员变量用m_开头,如一个长型成员变量定义为m_lCount;即：变量名=m_+变量类型+变量的英文意思（或缩写）    
    ⑥、对枚举类型（enum）中的变量，要求用枚举变量或其缩写做前缀。并且要求用大写。    
    如：enum     cmEMDAYS    
    {    
    EMDAYS_MONDAY;    
    EMDAYS_TUESDAY;    
    ……    
    };    
    ⑦、对struct、union、class变量的命名要求定义的类型用大写。并要加上前缀，其内部变量的命名规则与变量命名规则一致。    
    结构一般用S开头    
    如：struct     ScmNPoint    
    {    
    int     nX;//点的X位置    
    int     nY;     //点的Y位置    
    };    
    联合体一般用U开头    
    如:     union     UcmLPoint    
    {    
    long     lX;    
    long     lY;    
    }    
    类一般用C开头    
    如：    
    class     CcmFPoint    
    {    
    public:    
    float     fPoint;    
    };    
    对一般的结构应该定义为类模板，为以后的扩展性考虑    
    如：    
    template    
    class     CcmTVector3d    
    {    
    public:    
    TYPE     x,y,z;    
    };    
    ⑧、对常量（包括错误的编码）命名，要求常量名用大写，常量名用英文表达其意思。    
    如：#define     CM_FILE_NOT_FOUND     CMMAKEHR(0X20B)     其中CM表示类别。    
    ⑨、对const     的变量要求在变量的命名规则前加入c_,即：c_+变量命名规则；例如：    
    const     char*     c_szFileName;    
    2、     函数的命名规范：    
    函数的命名应该尽量用英文表达出函数完成的功能。遵循动宾结构的命名法则，函数名中动词在前,并在命名前加入函数的前缀，函数名的长度不得少于8个字母。    
    例如：    
    long     cmGetDeviceCount(……);    
    3、函数参数规范：    
    ①、     参数名称的命名参照变量命名规范。    
    ②、     为了提高程序的运行效率，减少参数占用的堆栈，传递大结构的参数，一律采用指针或引用方式传递。    
    ③、     为了便于其他程序员识别某个指针参数是入口参数还是出口参数，同时便于编译器检查错误，应该在入口参数前加入const标志。如：    
    ……cmCopyString(const     char     *     c_szSource,     char     *     szDest)    
    4、引出函数规范：    
    对于从动态库引出作为二次开发函数公开的函数，为了能与其他函数以及Windows的函数区分，采用类别前缀+基本命名规则的方法命名。例如：在对动态库中引出的一个图象编辑的函数定义为     imgFunctionname(其中img为image缩写)。    
    现给出三种库的命名前缀：    
    ①、     对通用函数库，采用cm为前缀。    
    ②、     对三维函数库，采用vr为前缀。    
    ③、     对图象函数库，采用img为前缀。    
    对宏定义，结果代码用同样的前缀。    
    5、文件名(包括动态库、组件、控件、工程文件等)的命名规范：    
    文件名的命名要求表达出文件的内容，要求文件名的长度不得少于5个字母，严禁使用象file1,myfile之类的文件名。    

三、注释规范：    
    1、函数头的注释    
    对于函数，应该从“功能”，“参数”，“返回值”、“主要思路”、“调用方法”、“日期”六个方面用如下格式注释：    
    //程序说明开始    
    //================================================================//    
    //     功能：     从一个String     中删除另一个String。    
    //     参数：     strByDelete,strToDelete    
    //     （入口）     strByDelete:     被删除的字符串（原来的字符串）    
    //     （出口）     strToDelete:     要从上个字符串中删除的字符串。    
    //     返回：     找到并删除返回1，否则返回0。（对返回值有错误编码的要//     求列出错误编码）。    
    //     主要思路：本算法主要采用循环比较的方法来从strByDelete中找到    
    //     与strToDelete相匹配的字符串，对多匹配strByDelete    
    //     中有多个strToDelete子串）的情况没有处理。请参阅：    
    //     书名......    
    //     调用方法：......    
    //     日期：起始日期，如：2000/8/21.9:40--2000/8/23.21:45    
    //================================================================//    
    函数名(……)    
    //程序说明结束    
    ①、     对于某些函数，其部分参数为传入值，而部分参数为传出值，所以对参数要详细说明该参数是入口参数，还是出口参数，对于某些意义不明确的参数还要做详细说明（例如：以角度作为参数时，要说明该角度参数是以弧度（PI）,还是以度为单位）,对既是入口又是出口的变量应该在入口和出口处同时标明。等等。    
    ②、     函数的注释应该放置在函数的头文件中，在实现文件中的该函数的实现部分应该同时放置该注释。    
    ③、     在注释中应该详细说明函数的主要实现思路、特别要注明自己的一些想法，如果有必要则应该写明对想法产生的来由。对一些模仿的函数应该注释上函数的出处。    
    ④、     在注释中详细注明函数的适当调用方法，对于返回值的处理方法等。在注释中要强调调用时的危险方面，可能出错的地方。    
    ⑤、     对日期的注释要求记录从开始写函数到结束函数的测试之间的日期。    
    ⑥、     对函数注释开始到函数命名之间应该有一组用来标识的特殊字符串。    
    如果算法比较复杂，或算法中的变量定义与位置有关，则要求对变量的定义进行图解。对难以理解的算法能图解尽量图解。    
    2、变量的注释：    
    对于变量的注释紧跟在变量的后面说明变量的作用。原则上对于每个变量应该注释，但对于意义非常明显的变量，如：i,j等循环变量可以不注释。    
    例如：     long     lLineCount     //线的根数。    
    　3、文件的注释：    
    文件应该在文件开头加入以下注释：    
    /////////////////////////////////////////////////////////////////////    
    //     工程:     文件所在的项目名。    
    //     作者：**，修改者：**    
    //     描述:说明文件的功能。    
    //     主要函数：…………    
    //     版本:     说明文件的版本，完成日期。    
    //     修改:     说明对文件的修改内容、修改原因以及修改日期。    
    //     参考文献：     ......    
    /////////////////////////////////////////////////////////////////////    
    为了头文件被重复包含要求对头文件进行定义如下:    
    #ifndef     __FILENAME_H__    
    #define     __FILENAME_H__    
    其中FILENAME为头文件的名字。    
    　　　4、其他注释：    
    在函数内我们不需要注释每一行语句。但必须在各功能模块的每一主要部分之前添加块注释，注释每一组语句，在循环、流程的各分支等，尽可能多加以注释。    
    其中的循环、条件、选择等位置必须注释。    
    对于前后顺序不能颠倒的情况，建议在注释中增加序号。    
    例如：    
    在其他顺序执行的程序中，每隔3—5行语句，必须加一个注释，注明这一段语句所组成的小模块的作用。对于自己的一些比较独特的思想要求在注释中标明。    

四、程序健壮性：    
    1、函数的返回值规范：    
    对于函数的返回位置，尽量保持单一性，即一个函数尽量做到只有一个返回位置。(单入口单出口)。    
    要求大家统一函数的返回值，所有的函数的返回值都将以编码的方式返回。    
    例如编码定义如下：    
    #define     CM_POINT_IS_NULL     CMMAKEHR(0X200)    
    :    
    :    
    建议函数实现如下：    
    long     函数名(参数,……)    
    {    
    long     lResult;     //保持错误号    
    lResult=CM_OK;    
    //如果参数有错误则返回错误号    
    if(参数==NULL)    
    {    
    lResult=CM_POINT_IS_NULL;    
    goto     END;    
    }    
    ……    
    END:    
    return     lResult;    
    }    
    2、关于goto的应用：    
    对goto语句的应用，我们要求尽量少用goto语句。对一定要用的地方要求只能向后转移。    
    3、资源变量的处理（资源变量是指消耗系统资源的变量）：    
    对资源变量一定赋初值。分配的资源在用完后必须马上释放，并重新赋值。    
    4、对复杂的条件判断，为了程序的可读性，应该尽量使用括号。    
    例：if(((szFileName!=NULL)&&(lCount>=0)))||(bIsRead==TRUE))    
 
五、可移植性：    
    1、高质量的代码要求能够跨平台，所以我们的代码应该考虑到对不同的平台的支持，特别是对windows98和windowsnt的支持。    
    2、由于C语言的移植性比较好，所以对算法函数要求用C代码，不能用C++代码。    
    3、对不同的硬件与软件的函数要做不同的处理
匈牙利命名法


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


一般前缀命名规范   前缀   类型   实例  
C   类或结构   CDocument，CPrintInfo  
m_   成员变量   m_pDoc，m_nCustomers  


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


应用程序符号命名规范   前缀   符号类型   实例   范围  
IDR_     不同类型的多个资源共享标识   IDR_MAIINFRAME   1～0x6FFF  
IDD_   对话框资源   IDD_SPELL_CHECK     1～0x6FFF  
HIDD_   对话框资源的Help上下文   HIDD_SPELL_CHECK     0x20001～0x26FF  
IDB_     位图资源   IDB_COMPANY_LOGO     1～0x6FFF  
IDC_   光标资源   IDC_PENCIL     1～0x6FFF  
IDI_   图标资源   IDI_NOTEPAD     1～0x6FFF  
ID_   来自菜单项或工具栏的命令   ID_TOOLS_SPELLING     0x8000～0xDFFF  
HID_   命令Help上下文   HID_TOOLS_SPELLING     0x18000～0x1DFFF  
IDP_   消息框提示   IDP_INVALID_PARTNO     8～0xDEEF  
HIDP_   消息框Help上下文   HIDP_INVALID_PARTNO     0x30008～0x3DEFF  
IDS_   串资源   IDS_COPYRIGHT     1～0x7EEF  
IDC_   对话框内的控件   IDC_RECALC     8～0xDEEF  


Microsoft   MFC宏命名规范   名称   类型  
_AFXDLL   唯一的动态连接库（Dynamic   Link   Library，DLL）版本  
_ALPHA   仅编译DEC   Alpha处理器  
_DEBUG   包括诊断的调试版本  
_MBCS   编译多字节字符集  
_UNICODE   在一个应用程序中打开Unicode  
AFXAPI     MFC提供的函数  
CALLBACK   通过指针回调的函数    


库标识符命名法   标识符   值和含义  
u     ANSI（N）或Unicode（U）  
d     调试或发行：D   =   调试；忽略标识符为发行。  


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


动态连接库命名规范   名称   类型  
_AFXDLL   唯一的动态连接库（DLL）版本
 
WINAPI     Windows所提供的函数  


Windows.h中新的命名规范   类型   定义描述  
WINAPI   使用在API声明中的FAR   PASCAL位置，如果正在编写一个具有导出API人口点的DLL，则可以在自己的API中使用该类型  
CALLBACK   使用在应用程序回叫例程，如窗口和对话框过程中的FAR   PASCAL的位置  
LPCSTR   与LPSTR相同，只是LPCSTR用于只读串指针，其定义类似（const   char   FAR*）  
UINT   可移植的无符号整型类型，其大小由主机环境决定（对于Windows   NT和Windows   9x为32位）；它是unsigned   int的同义词  
LRESULT   窗口程序返回值的类型  
LPARAM   声明lParam所使用的类型，lParam是窗口程序的第四个参数  
WPARAM   声明wParam所使用的类型，wParam是窗口程序的第三个参数  
LPVOID   一般指针类型，与（void   *）相同，可以用来代替LPSTR    

容程序是会崩溃的，而后者完全正确。
程序演示：
测试环境Devc++
代码
运行结果
2293628 4199056 abc
2293624 2293624 abc
2293620 4199056 abc

#include <iostream>
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();
}

参考资料：
首先要搞清楚编译程序占用的内存的分区形式：
一、预备知识-程序的内存分配
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）-由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于

数据结构中的栈。
2、堆区（heap）-一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据

结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）-全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态

变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统

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

该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大

小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正

好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
2.3申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地

址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译

时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间

较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地

址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的

虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
2.4申请效率的比较：
栈:由系统自动分配，速度较快。但程序员是无法控制的。
堆:是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
另外，在WINDOWS下，最好的方式是用Virtual Alloc分配内存，他不是在堆，也不是在栈,而是直接在进

程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。
2.5堆和栈中的存储内容
栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的

地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变

量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主

函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。
2.6存取效率的比较
char s1[]="aaaaaaaaaaaaaaa";
char *s2="bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：
#include
voidmain()
{
char a=1;
char c[]="1234567890";
char *p="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇编代码
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
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据

edx读取字符，显然慢了。
2.7小结：
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会

切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

自我总结：
char *c1 = "abc";实际上先是在文字常量区分配了一块内存放"abc",然后在栈上分配一地址给c1并指向

这块地址，然后改变常量"abc"自然会崩溃

然而char c2[] = "abc",实际上abc分配内存的地方和上者并不一样，可以从
4199056
2293624 看出，完全是两块地方，推断4199056处于常量区，而2293624处于栈区

2293628
2293624
2293620 这段输出看出三个指针分配的区域为栈区，而且是从高地址到低地址

2293620 4199056 abc 看出编译器将c3优化指向常量区的"abc"

继续思考：
代码：

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

#include <iostream>
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();
}

1)函数参数的压栈顺序，2)由调用者还是被调用者把参数弹出栈，3)以及产生函数修饰名的方法。

1、__stdcall调用约定：函数的参数自右向左通过栈传递，被调用的函数在返回前清理传送参数的内存栈，

2、_cdecl是C和C＋＋程序的缺省调用方式。每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用_stdcall函数的大。函数采用从右到左的压栈方式。注意：对于可变参数的成员函数，始终使用__cdecl的转换方式。

3、__fastcall调用约定：它是通过寄存器来传送参数的（实际上，它用ECX和EDX传送前两个双字（DWORD）或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈）。

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

5、naked call采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。naked call不产生这样的代码。naked call不是类型修饰符，故必须和_declspec共同使用。

调用约定可以通过工程设置：Setting...\C/C++ \Code Generation项进行选择，缺省状态为__cdecl。

名字修饰约定：

1、修饰名(Decoration name)："C"或者"C++"函数在内部（编译和链接）通过修饰名识别
2、C编译时函数名修饰约定规则：
__stdcall调用约定在输出函数名前加上一个下划线前缀，后面加上一个"@"符号和其参数的字节数，格式为_functionname@number,例如：function(int a, int b)，其修饰名为：_function@8
__cdecl调用约定仅在输出函数名前加上一个下划线前缀，格式为_functionname。
__fastcall调用约定在输出函数名前加上一个"@"符号，后面也是一个"@"符号和其参数的字节数，格式为@functionname@number。

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

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

__cdecl调用约定：
规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YA"。
__fastcall调用约定：
规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YI"。
VC++对函数的省缺声明是"__cedcl",将只能被C/C++调用.

注意：
1、_beginthread需要__cdecl的线程函数地址，_beginthreadex和CreateThread需要__stdcall的线程函数地址。

2、一般WIN32的函数都是__stdcall。而且在Windef.h中有如下的定义：
 #define CALLBACK __stdcall
 #define WINAPI　 __stdcall

3、extern "C" _declspec(dllexport) int __cdecl Add(int a, int b);
   typedef int (__cdecl*FunPointer)(int a, int b);
   修饰符的书写顺序如上。

4、extern "C"的作用：如果Add(int a, int b)是在c语言编译器编译，而在c++文件使用，则需要在c++文件中声明：extern "C" Add(int a, int b)，因为c编译器和c++编译器对函数名的解释不一样（c++编译器解释函数名的时候要考虑函数参数，这样是了方便函数重载，而在c语言中不存在函数重载的问题），使用extern "C"，实质就是告诉c++编译器，该函数是c库里面的函数。如果不使用extern "C"则会出现链接错误。
一般象如下使用：
#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、MFC提供了一些宏，可以使用AFX_EXT_CLASS来代替__declspec(DLLexport)，并修饰类名，从而导出类，AFX_API_EXPORT来修饰函数，AFX_DATA_EXPORT来修饰变量
AFX_CLASS_IMPORT：__declspec(DLLexport)
AFX_API_IMPORT：__declspec(DLLexport)
AFX_DATA_IMPORT：__declspec(DLLexport)
AFX_CLASS_EXPORT：__declspec(DLLexport)
AFX_API_EXPORT：__declspec(DLLexport)
AFX_DATA_EXPORT：__declspec(DLLexport)
AFX_EXT_CLASS：#ifdef _AFXEXT
   AFX_CLASS_EXPORT
        #else
   AFX_CLASS_IMPORT

6、DLLMain负责初始化(Initialization)和结束(Termination)工作，每当一个新的进程或者该进程的新的线程访问DLL时，或者访问DLL的每一个进程或者线程不再使用DLL或者结束时，都会调用DLLMain。但是，使用TerminateProcess或TerminateThread结束进程或者线程，不会调用DLLMain。

7、一个DLL在内存中只有一个实例
DLL程序和调用其输出函数的程序的关系：
1)、DLL与进程、线程之间的关系
DLL模块被映射到调用它的进程的虚拟地址空间。
DLL使用的内存从调用进程的虚拟地址空间分配，只能被该进程的线程所访问。
DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。
DLLDLL可以有自己的数据段，但没有自己的堆栈，使用调用进程的栈，与调用它的应用程序相同的堆栈模式。

2)、关于共享数据段
DLL定义的全局变量可以被调用进程访问；DLL可以访问调用进程的全局数据。使用同一DLL的每一个进程都有自己的DLL全局变量实例。如果多个线程并发访问同一变量，则需要使用同步机制；对一个DLL的变量，如果希望每个使用DLL的线程都有自己的值，则应该使用线程局部存储(TLS，Thread Local Strorage)。

 Visual C++ Compiler Options可以指定的Calling Convention有 3种：
    /Gd /Gr /Gz

    这三个参数决定了：

    1.函数参数以何种顺序入栈，右到左还是左到右。
    2.在函数运行完后，是调用函数还是被调用函数清理入栈的参数。
    3.在编译时函数名字是如何转换的。

    下面我们分别详细介绍：

    1./Gd
        这是编译器默认的转换模式，对一般函数使用 C的函数调用转换方式__cdecl，
        但是对于C++ 成员函数和前面修饰了__stdcall __fastcall的函数除外。

    2./Gr
        对于一般函数使用__fastcall函数调用转换方式，所有使用__fastcall的函数
        必须要有函数原形。但对于C++ 成员函数和前面修饰了__cdecl __stdcall 的函数除外。

    3./Gz
        对于所有 C函数使用__stdcall函数调用转换方式，但对于可变参数的 C函数以
        及用__cdecl __fastcall修饰过的函数和C++ 成员函数除外。所有用__stdcall
        修饰的函数必须有函数原形。

        事实上，对于x86系统，C++ 成员函数的调用方式有点特别，将成员函数的this
        指针放入ECX，所有函数参数从右向左入栈，被调用的成员函数负责清理入栈的
        参数。对于可变参数的成员函数，始终使用__cdecl的转换方式。

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

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

    2.__fastcall
        有一些函数调用的参数被放入ECX，EDX中，而其它参数从右向左入栈。被调用
        函数在它将要返回时负责清理入栈的参数。在内嵌汇编语言的时候，需要注意
        寄存器的使用，以免与编译器使用的产生冲突。函数名字的转换是：
                　　@functionname@number
        没有函数名大小写的转换，number表示函数参数的字节数。由于有一些参数不
        需要入栈，所以这种转换方式会在一定程度上提高函数调用的速度。

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

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

    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             ;修正栈
                 xor     eax, eax
                 pop     ebp
                 retn

    2.__fastcall

        @function@8
                 push    ebp
                 mov     ebp, esp           ;保存栈指针
                 sub     esp, 8             ;多了两个局部变量
                 mov     [ebp-8], edx       ;保存参数 2
                 mov     [ebp-4], ecx       ;保存参数 1
                 mov     eax, [ebp-4]       ;参数 1
                 add     eax, [ebp-8]       ;加上参数 2
                 mov     esp, ebp           ;修正栈
                 pop     ebp
                 retn
        _main
                 push    ebp
                 mov     ebp, esp
                 mov     edx, 14h           ;参数 2给EDX
                 mov     ecx, 0Ah           ;参数 1给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                  ;修复栈
        _main
                 push    ebp
                 mov     ebp, esp
                 push    14h                ;参数 2入栈
                 push    0Ah                ;参数 1入栈
　               call    _function@8　　　　;函数调用
                 xor     eax, eax
                 pop     ebp
                 retn

    可见上述三种方法各有各的特点，而且_main必须是__cdecl，一般WIN32的函数都是
    __stdcall。而且在Windef.h中有如下的定义：

    #define CALLBACK __stdcall
    #define WINAPI　 __stdcall

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

在带参数的构造函数中，初始化列表的初始化变量顺序是根据成员变量的声明顺序来执行的，因此m_i会被
赋予一个随机值，输出是
-858993460
98
如果在声明变量为
 int m_j;

class A
{
   const int Size = 0;
}

class A
{
   A()
  {
  const int Size = 10;
}
}; 

 static 声明的变量在C语言中有两方面的特征：
　　1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。
　　2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。
Tips:
　　A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；
　　B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；
　　C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题；
        D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数)
        E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。

扩展分析:术语static有着不寻常的历史.起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后，static在C中有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。最后，C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。

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

变量可以分为：全局变量、静态全局变量、静态局部变量和局部变量。
          按存储区域分，全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区。
          按作用域分，全局变量在整个工程文件内都有效；静态全局变量只在定义它的文件内有效；静态局部变量只在定义它的函数内有效，只是程序仅分配一次内存，函数返回后，该变量不会消失；局部变量在定义它的函数内有效，但是函数返回后失效。

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

　　从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。

　　static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

　　static全局变量与普通的全局变量有什么区别：static全局变量只初始化一次，防止在其他文件单元中被引用;
　　static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
       static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝
       全局变量和静态变量如果没有手工初始化，则由编译器初始化为0。局部变量的值不可知。

当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话，我举例来说明。我们要同时编译两个源文件，一个是a.c，另一个是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;
            }
            

程序的运行结果是：

A Hello

你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使用？前面说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问。此例中，a是全局变量，msg是函数，并且都没有加static前缀，因此对于另外的源文件main.c是可见的。

如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。

2.static的第二个作用是保持变量内容的持久。

存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。虽然这种用法不常见，但我还是举一个例子。

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

程序的运行结果是：

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的第三个作用是默认初始化为0.其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。

在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵，我们可以一个一个地把所有元素都置0，然后把不是0的几个元素赋值。如果定义成静态的，就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用，但又觉得每次在字符数组末尾加‘\0’太麻烦。如果把字符串定义成静态的，就省去了这个麻烦，因为那里本来就是‘\0’。不妨做个小实验验证一下。

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

程序的运行结果如下integer： 0； string： （begin）（end）

最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏，其次因为static变量存放在静态存储区，所以它具备持久性和默认值0.

如果将来你不打算升级到unicode，那么也不需要_T。

_t("hello world")

在ansi的环境下，它是ansi的，如果在unicode下，那么它将自动解释为双字节字符串，既unicode编码。

这样做的好处，不管是ansi环境，还是unicode环境，都适用。

那么在VC++中，字符串_T("ABC")和一个普通的字符串"ABC"有什么区别呢？

_T("ABC")

如果定义了unicode，它将表示为L"ABC"，每个字符为16位，宽字符串。

如果没有定义unicode，它就是ascii的"ABC"，每个字符为8位。

相当于

#ifdef _UNICODE

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

#else

#define _T("ABC") "ABC"

#endif

_T("ABC")中的一个字符和汉字一样，占两个字节，而在"ABC"中，英文字符占一个字节，汉字占两个字节。

一、 在字符串前加一个L作用:

   如 L"我的字符串"   表示将ANSI字符串转换成unicode的字符串，就是每个字符占用两个字节。

strlen("asd") =   3;

strlen(L"asd") =   6;

   二、   _T宏可以把一个引号引起来的字符串，根据你的环境设置，使得编译器会根据编译目标环境选择合适的（Unicode还是ANSI）字符处理方式

   如果你定义了UNICODE，那么_T宏会把字符串前面加一个L。这时 _T("ABCD") 相当于 L"ABCD" ，这是宽字符串。

   如果没有定义，那么_T宏不会在字符串前面加那个L，_T("ABCD") 就等价于 "ABCD"

三、TEXT,_TEXT 和_T 一样的

如下面三语句：

TCHAR szStr1[] = TEXT("str1");

char szStr2[] = "str2";

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

那么第一句话在定义了UNICODE时会解释为第三句话，没有定义时就等于第二句话。  

但二句话无论是否定义了UNICODE都是生成一个ANSI字符串，而第三句话总是生成UNICODE字符串。

为了程序的可移植性，建议都用第一种表示方法。

但在某些情况下，某个字符必须为ANSI或UNICODE，那就用后两种方法

      char :单字节变量类型，最多表示256个字符

      wchar_t :宽字节变量类型，用于表示Unicode字符

      它实际定义在<string.h>里：typedef unsigned short wchar_t。

      为了让编译器识别Unicode字符串，必须以在前面加一个“L”,定义宽字节类型方法如下：

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

     其中，宽字节类型每个变量占用2个字节，故上述数组a的sizeof(a) = 14

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

#ifdef UNICODE
typedef char TCHAR;
#else
typede wchar_t TCHAR;
#endif
_T( )也是定义在该头文件中的宏，视是否定义了_UNICODE宏而定义成：
定义了_UNICODE：    #define _T(x) L##x
没有定义_UNICODE： #define _T(x) x
注意：如果在程序中使用了TCHAR，那么就不应该使用ANSI的strXXX函数或者Unicode的wcsXXX函数了，而必须使用tchar.h中定义的_tcsXXX函数。

以strcpy函数为例子，总结一下：
 

//如果你想使用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语言标准数据类型，字符型，至于由几个字节组成通常由编译器决定，一般一个字节。Windows为了消除各 编译器的差别，重新定义了一些数据类型，你提到了另外几个类型都是这样。
CHAR为单字节字符。
还有个WCHAR为Unicode字符，即不论中英文，每 个字有两个字节组成。
如果当前编译方式为ANSI(默认)方式，TCHAR等价于CHAR，
如果为Unicode方式，TCHAR等价于WCHAR。
在当 前版本LPCSTR和LPSTR没区别，即以零结尾的字符串指针，相当于CHAR *。

char :单字节变量类型，最多表示256个字符，

wchar_t :宽字节变量类型，用于表示Unicode字符，

它实际定义在<string.h>里：typedef unsigned short wchar_t。

为了让编译器识别Unicode字符串，必须以在前面加一个“L”,定义宽字节类型方法如下：

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

其中，宽字节类型每个变量占用2个字节，故上述数组a的sizeof(a) = 14

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

#ifdef UNICODE
typedef char TCHAR;
#else
typede wchar_t TCHAR;
#endif
_T( )也是定义在该头文件中的宏，视是否定义了_UNICODE宏而定义成：
定义了_UNICODE：    #define _T(x) L##x
没有定义_UNICODE： #define _T(x) x
注意：如果在程序中使用了TCHAR，那么就不应该使用ANSI的strXXX函数或者Unicode的wcsXXX函数了，而必须使用tchar.h中定义的_tcsXXX函数。

以strcpy函数为例子，总结一下：
 

//如果你想使用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了！他分析了原因后总结：如 果您正开始一个新的项目，请无论如何也要顶住压力，直接使用UNICODE编码！切记！您只需要对您的组员进行10分钟的培训，记住strcpy用 wcscpy，sprintf用swprintf代替，常数前加L，就可以了！它不会花您很多时间的，带给您的是稳定和安全！相信偶，没错的！！

一、 在字符串前加一个L作用:
   如  L"我的字符串"    表示将ANSI字符串转换成unicode的字符串，就是每个字符占用两个字节。
  strlen("asd")   =   3;  
  strlen(L"asd")   =   6;
  二、  _T宏可以把一个引号引起来的字符串，根据你的环境设置，使得编译器会根据编译目标环境选择合适的（Unicode还是ANSI）字符处理方式
   如果你定义了UNICODE，那么_T宏会把字符串前面加一个L。这时 _T("ABCD") 相当于 L"ABCD" ，这是宽字符串。
   如果没有定义，那么_T宏不会在字符串前面加那个L，_T("ABCD") 就等价于 "ABCD"
三、TEXT,_TEXT 和_T 一样的
如下面三语句：  
  TCHAR   szStr1[]   =   TEXT("str1");  
  char   szStr2[]   =   "str2";  
  WCHAR   szStr3[]   =   L("str3");  
  那么第一句话在定义了UNICODE时会解释为第三句话，没有定义时就等于第二句话。  
  但二句话无论是否定义了UNICODE都是生成一个ANSI字符串，而第三句话总是生成UNICODE字符串。  
  为了程序的可移植性，建议都用第一种表示方法。  
  但在某些情况下，某个字符必须为ANSI或UNICODE，那就用后两种方法。

CSDN:superarhow说： 不要再使用TCHAR和_T了！他分析了原因后总结：如 果您正开始一个新的项目，请无论如何也要顶住压力，直接使用UNICODE编码！切记！您只需要对您的组员进行10分钟的培训，记住strcpy用 wcscpy，sprintf用swprintf代替，常数前加L，就可以了！它不会花您很多时间的，带给您的是稳定和安全！相信偶，没错的！！

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

const修饰变量，一般有两种写法：

const TYPE value;

TYPE const value;

这两种写法在本质上是一样的。它的含义是：const修饰的类型为TYPE的变量value是不可变的。

对于一个非指针的类型TYPE，无论怎么写，都是一个含义，即value只不可变。

例如：

const int nValue；         //nValue是const

int const nValue；    // nValue是const

但是对于指针类型的TYPE，不同的写法会有不同情况，例如：

A. const char *pContent;

B. char * const pContent;

C. char const *pContent;

D. const char* const pContent;

对于前三种写法，我们可以换个方式，给其加上括号

A. const (char) *pContent;

B. (char*) const pContent;

C. (char) const *pContent;

这样就一目了然。根据对于const修饰非指针变量的规则，很明显，A=C.

- 对于A,C, const修饰的类型为char的变量*pContent为常量，因此，pContent的内容为常量不可变.

- 对于B, const修饰的类型为char*的变量pContent为常量，因此，pContent指针本身为常量不可变.

- 对于D, 其实是A和B的混合体，表示指针本身和指针内容两者皆为常量不可变

总结:

(1)  指针本身是常量不可变

(char*) const pContent;

(2)  指针所指向的内容是常量不可变

const (char) *pContent;

(char) const *pContent;

(3)  两者都不可变

const char* const pContent;

还有其中区别方法：

沿着*号划一条线，

如果const位于*的左侧，则const就是用来修饰指针所指向的内容变量，即指针指向为常量（物常量）；

如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量（指针常量）。

小例子：
char ch[5] = "lisi";
const char* pStr = ch;
*pStr = 'w';  //error，物常量，不可更改内容
pStr ="wangwu"; //OK，物常量，可更改指针

cha ch[5] = "lisi";
char * const pStr = "lisi";
pStr = "zhangsan"; //error，指针常量，不可更改指针
*pStr = "w"; //OK ，指针常量，可更改内容

2. const修饰函数参数

const修饰函数参数是它最广泛的一种用途，它表示函数体中不能修改参数的值(包括参数本身的值或者参数其中包含的值)。它可以很好

void function(const int Var); //传递过来的参数在函数内不可以改变(无意义，因为Var本身就是形参)

void function(const char* Var); //参数指针所指内容为常量不可变

void function(char* const Var); //参数指针本身为常量不可变(也无意义， 因为char* Var也是形参)

参数为引用，为了增加效率同时防止修改。

修饰引用参数时：

void function(const Class& Var);//引用参数在函数内不可以改变

void function(const TYPE& Var); //引用参数在函数内为常量不可变

3. const 修饰函数返回值

const修饰函数返回值其实用的并不是很多，它的含义和const修饰普通变量以及指针的含义基本相同。

(1) const int fun1() 这个其实无意义，因为参数返回本身就是赋值。

(2) const int * fun2()

调用时 const int *pValue = fun2();

我们可以把fun2()看作成一个变量，那么就是我们上面所说的1.(1)的写法，即指针内容不可变。

(3) int* const fun3()

调用时 int * const pValue = fun2();

我们可以把fun2()看作成一个变量，那么就是我们上面所说的1.(2)的写法，即指针本身不可变。

4. const修饰类对象/对象指针/对象引用

const修饰类对象表示该对象为常量对象，其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。

const修饰的对象，该对象的任何非const成员函数都不能被调用，因为任何非const成员函数会有修改成员变量的企图。

例如：

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修饰类的成员函数，表示成员常量，不能被修改，同时它只能在初始化列表中赋值。

class A

{

   …

   const int nValue;       //成员常量不能被修改

   …

   A(int x): nValue(x) {}; //只能在初始化列表中赋值

}

6. const修饰成员函数

const修饰类的成员函数，则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。

class A

{

   …

void function()const; //常成员函数, 它不改变对象的成员变量. 也不能调用类中任何非const成员函数。

}

对于const类对象/指针/引用，只能调用类的const成员函数，因此，const修饰成员函数的最重要作用就是限制对于const对象的使用。

7. const常量与define宏定义的区别

(1) 编译器处理方式不同

define宏是在预处理阶段展开。

const常量是编译运行阶段使用。

(2) 类型和安全检查不同

define宏没有类型，不做任何类型检查，仅仅是展开。

const常量有具体的类型，在编译阶段会执行类型检查。

(3) 存储方式不同

define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。

const常量会在内存中分配(可以是堆中也可以是栈中)。

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

其实，除了random函数，还有一个rand函数，这个函数也是一个随机函数，他可以产生从0到rand_max(32767)的随机数。

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

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

大家可以把以上的代码编译运行一下，发现他的确产生随机数了，但是你会发现，每次运行程序产生的随机数都是一样的，不过你在程序里加上for循环，每次产生的数不一样，但是，如果再运行这个程序，它产生的数据却都是相同的。

那么如何写一个程序，让它每次运行时产生的随机数都不一样呢？ 请看下面的例子：

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

这时运行程序，会发现每次产生的随机数都不一样。

那么为什么第一个程序一样而第二个程序一样呢？

第二个程序用到了一个新的函数srand

这个函数是给随机数产生一个随机种子(seed)，函数原型是srand( (unsigned)time( NULL ) );

time的值每时每刻都不同。所以种子不同，所以，产生的随机数也不同。

所以说，要想产生不同的随机数，在使用rand之前需要先调用srand

srand和rand函数都包含在stdlib.h的头文件里。

由于rand产生的随机数是从0到rand_max的，而rand_max（32767）是一个很大的数，那么如何产生从X~Y的数呢？

从X到Y，有Y－X＋1个数，所以要产生从X到Y的数，只需要这样写：

k = rand() % (Y - X + 1) +X;

这样，就可以产生你想要的任何范围内的随机数了。
问题：如何生成K个小于Ｎ并且互不重复的整数

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

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

二.考虑如何让数据不重复 
  看代码吧。。学习下方法
首先搞个一绝没有重复数据的数组，就是x[i]=i;
此时注意那个swap函数，每次生成的随机数作为数组下标去取数，然后交换，这就保证了x这个数组绝不会有重复的数出现。
绝了！！