C++常用技巧一

• 1.CString   到   int 
    int   a; 
    CString   b="12"; 
    a=atoi((const   char   *)b);  
• 
  2.int   到   CString
    int   a=12; 
    CString   b; 
    b.Format("%d",a); 

• 3. C++ Windows SDK 字符及字符串指针定义

typedef CHAR *LPSTR;

typedef WCHAR *LPWSTR；

typedef CONST CHAR *LPCSTR;

typedef CONST WCHAR *LPCWSTR;

首先说说TCHAR，它是被这样定义的：

#ifdef UNICODE

typedef  WCHAR TCHAR;

#else

typedef  char TCHAR

#ifdef   UNICODE

typedef LPWSTR LPTSTR;

#else

typedef  LPSTR LPTSTR;

LPSTR  -------    char*

LPCSTR -------  const char*

LPWSTR -------  wchar_t*

LPCWSTR --------   const wchar_t*

• 4.将CString转为CTime的几种方法

CString   timestr   =   "2000年04月05日";  
int   a,b,c   ;  
sscanf(timestr.GetBuffer(timestr.GetLength()),"%d年%d月%d日",&a,&b,&c);  
CTime   time(a,b,c,0,0,0);   

CString   s("2001-8-29   19:06:23");  
int   nYear,   nMonth,   nDate,   nHour,   nMin,   nSec;  
sscanf(s,   "%d-%d-%d   %d:%d:%d",   &nYear,   &nMonth,   &nDate,   &nHour,   &nMin,   &nSec);  
CTime   t(nYear,   nMonth,   nDate,   nHour,   nMin,   nSec);

5.将CTime转换为CString的方法

CTime  tmSCan = CTime::GetCurrentTime();

CString szTime = tmScan.Format("'%Y-%m-%d %H:%M:%S'");

这样得到的日期时间字符串就是以"2006-11-27 23:30:59"的格式.这是不是很方便呢?

//取得CTime中的日期
CString cstrDate = tmScan.Format("%Y-%m-%d");

//取得CTime中的时间
CString cstrTime = tmScan.Format("%H:%M-%S");

sprintf还有个不错的表妹：strftime，专门用于格式化时间字符串的，用法跟她表哥很像，也是一大堆格式控制符，只是毕竟小姑娘家心细，她还要调用者指定缓冲区的最大长度，可能是为了在出现问题时可以推卸责任吧。这里举个例子：

更多更好的sprintf()函数说明参考:《spirntf，你知道多少？》

http://blog.csdn.net/steedhorse/archive/2005/03/25/330206.aspx

time_t t = time(0);

//产生"YYYY-MM-DD hh:mm:ss"格式的字符串。

char s[32];

strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", localtime(&t));

sprintf在MFC中也能找到他的知音：CString::Format，strftime在MFC中自然也有她的同道：CTime::Format，这一对由于从面向对象哪里得到了赞助，用以写出的代码更觉优雅。

6.CString 转 URLCode

CString  UTF8Convert(CString  str,  int  sourceCodepage,  int  targetCodepage) 
{ 
    int  len=str.GetLength(); 
    int  unicodeLen=MultiByteToWideChar(sourceCodepage,0,str,-1,NULL,0); 
    wchar_t            *  pUnicode; 
    pUnicode=new  wchar_t[unicodeLen 1]; 
    memset(pUnicode,0,(unicodeLen 1)*sizeof(wchar_t)); 
    MultiByteToWideChar(sourceCodepage,0,str,-1,(LPWSTR)pUnicode,unicodeLen); 
    BYTE  *  pTargetData; 
    int  targetLen=WideCharToMultiByte(targetCodepage,0,(LPWSTR)pUnicode,-1,(char  *)pTargetData,0,NULL,NULL); 
    pTargetData=new  BYTE[targetLen 1]; 
    memset(pTargetData,0,targetLen 1); 
    WideCharToMultiByte(targetCodepage,0,(LPWSTR)pUnicode,-1,(char  *)pTargetData,targetLen,NULL,NULL); 
    CString  rt; 
    rt.Format(%s,pTargetData); 
    delete  pUnicode; 
    delete  pTargetData; 
    return  rt; 
} 
class URLClass
{
public:
    inline BYTE toHex(const BYTE x)
    {
        return x  9 ? x   55: x   48;
    }
    inline BYTE toByte(const BYTE x)
    {
        return x  57? x - 55: x - 48;
    }
    CString URLDecode(CString sIn)
    {
        CString sOut;
        const int nLen = sIn.GetLength()   1;
        register LPBYTE pOutTmp = NULL;
        LPBYTE pOutBuf = NULL;
        register LPBYTE pInTmp = NULL;
        LPBYTE pInBuf =(LPBYTE)sIn.GetBuffer(nLen);
        pOutBuf = (LPBYTE)sOut.GetBuffer(nLen);
        if(pOutBuf)
        {
            pInTmp   = pInBuf;
            pOutTmp = pOutBuf;
            while (*pInTmp)
            {
                if('%'==*pInTmp)
                {
                    pInTmp  ;
                    *pOutTmp   = (toByte(*pInTmp)4)   toByte(*(pInTmp 1));
                    pInTmp  ;
                }
                else if(' '==*pInTmp)
                    *pOutTmp   = ' ';
                else
                    *pOutTmp   = *pInTmp;
                pInTmp  ;
            }
            *pOutTmp = '\0';
            sOut.ReleaseBuffer();
        }
        sIn.ReleaseBuffer();
        return sOut;
    }
    CString URLEncode(CString sIn)
    {
        CString sOut;
        const int nLen = sIn.GetLength()   1;
        register LPBYTE pOutTmp = NULL;
        LPBYTE pOutBuf = NULL;
        register LPBYTE pInTmp = NULL;
        LPBYTE pInBuf =(LPBYTE)sIn.GetBuffer(nLen);
        pOutBuf = (LPBYTE)sOut.GetBuffer(nLen*3);
        if(pOutBuf)
        {
            pInTmp   = pInBuf;
            pOutTmp = pOutBuf;
            while (*pInTmp)
            {
                if(isalnum(*pInTmp) || '-'==*pInTmp || '_'==*pInTmp || '.'==*pInTmp||''==*pInTmp||'='==*pInTmp)
                    *pOutTmp   = *pInTmp;
                else if(isspace(*pInTmp))
                    *pOutTmp   = ' ';
                else
                {
                    *pOutTmp   = '%';
                    *pOutTmp   = toHex(*pInTmp4);
                    *pOutTmp   = toHex(*pInTmp);
                }
                pInTmp  ;
            }
            *pOutTmp = '\0';
            sOut.ReleaseBuffer();
        }
        sIn.ReleaseBuffer();
        return sOut;
    }
};
CString str=中国;
str=UTF8Convert(str,0,65001);
URLClass uc;
str=uc.URLEncode(str);

7.16进制字符串转数字

I、最简单的办法：sscanf(“12AB”,,”%x”,&lngHex);   //字符也可以为”0x12AB”
II、有个朋友，自行编写函数实现了该功能，据说速度比sscanf快：
     BOOL   HexToDec(   LPCTSTR   shex,int&   idec   ) 
     { 
      int   i,mid; 
      int   len   =   lstrlen(   shex   );     
      if(   len>8   )     return   FALSE;    
      mid   =   0;   idec   =   0; 
      for(   i=0;i<len;i++   ) 
      { 
          if(   shex[i]>='0'&&shex[i]<='9'   )   mid   =   shex[i]-'0'; 
          else   if(   shex[i]>='a'&&shex[i]<='f'   )   mid   =   shex[i]   -'a'   +10; 
          else   if(   shex[i]>='A'&&shex[i]<='F'   )   mid   =   shex[i]   -'A'   +10; 
          else   return   FALSE;     
          mid   <<=   ((len-i-1)<<2); 
          idec   |=   mid;     
      }     
      return   TRUE; 
   } 

8.数字转16进制字符串

1、C/C++

Printf(“%x”,1234);

2、VB

Hex(1234)

3、VB.net

Hex(1234)

Int(1234).ToString(“X4”)

4、C#

((int)1234).ToString(“X4”);

9.数字与8、16等进制的转换

char *_itoa( int value, char *str, int radix ); //包含在include<stdlib.h>

例如：

char str[16];

_itoa(123,str,16);//将数值123转换为16进制字符串，并存储在str中；

10. C++ 引用的相关知识点

a. 什么是“引用”？申明和使用“引用”要注意哪些问题？

　　答：引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。

b.  将“引用”作为函数参数有哪些特点？

　　（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

　　（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

　　（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

　c.  在什么时候需要使用“常引用”？

　　如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；

　　例1

　　int a ;

　　const int &ra=a;

　　ra=1; //错误

　　a=1; //正确

　　例2

　　string foo( );

　　void bar(string & s);

　　那么下面的表达式将是非法的：

　　bar(foo( ));

　　bar("hello world");

　　原因在于foo( )和"hello world"串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

　　引用型参数应该在能被定义为const的情况下，尽量定义为const 。

d. 将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?

　　格式：类型标识符 &函数名（形参列表及类型说明）{ //函数体 }

　　好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!

　　注意事项：

　　（1）不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

　　（2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。

　　（3）可以返回类成员的引用，但最好是const。