CString, BSTR, LPCTSTR 概念

CString是一個動態TCHAR數組，

BSTR是一種專有格式的字符串(須要用系統提供的函數來操縱 )

LPCTSTR只是一個常量的TCHAR指針。

CString 是一個徹底獨立的類，動態的TCHAR數組，封裝了+等操做符和字符串操做方法。

typedef OLECHAR FAR* BSTR;

typedef const char * LPCTSTR;

vc++中各類字符串的表示法 

   首先char* 是指向ANSI字符數組的指針，其中每一個字符佔據8位（有效數據是除掉最高位的其餘7位），這裏保持了與傳統的C,C++的兼容。

       LP的含義是長指針(long pointer)。LPSTR是一個指向以‘\0’結尾的ANSI字符數組的指針，與char*能夠互換使用，在win32中較多地使用LPSTR。而LPCSTR中增長的‘C’的含義是「CONSTANT」（常量），代表這種數據類型的實例不能被使用它的API函數改變，除此以外，它與LPSTR是等同的。

1.LP表示長指針,在win16下有長指針(LP)和短指針(P)的區別,而在win32下是沒有區別的,都是32位.因此這裏的LP和P是等價的.

2.C表示const

3.T是TCHAR,在採用Unicode方式編譯時是wchar_t,在普通時編譯成char.

   爲了知足程序代碼國際化的須要，業界推出了Unicode標準，它提供了一種簡單和一致的表達字符串的方法，全部字符中的字節都是16位的值，其數量也能夠知足差很少世界上全部書面語言字符的編碼需求，開發程序時使用Unicode（類型爲wchar_t)是一種被鼓勵的作法。

   LPWSTR與LPCWSTR由此產生，它們的含義相似於LPSTR與LPCSTR，只是字符數據是16位的wchar_t而不是char。

  爲了實現兩種編碼的通用，提出了TCHAR的定義：

若是定義_UNICODE，聲明以下：

  typedef wchar_t TCHAR;

若是沒有定義_UNICODE，則聲明以下：

  typedef char TCHAR;

LPTSTR和LPCTSTR中的含義就是每一個字符是這樣的TCHAR。

如  LPCTSTR:

  #ifdef _UNICODE

    typedef const wchar_t * LPCTSTR;

  #else

    typedef const char * LPCTSTR;

  #endif

CString類中的字符就是被聲明爲TCHAR類型的，它提供了一個封裝好的類供用戶方便地使用。

VC經常使用數據類型使用轉換詳解

先定義一些常見類型變量藉以說明

int i = 100;

long l = 2001;

float f=300.2;

double d=12345.119;

char username[]="女俠程佩君";

char temp[200];

char *buf;

CString str;

_variant_t v1;

_bstr_t v2;

1、其它數據類型轉換爲字符串

短整型(int)

   itoa(i,temp,10);  //將i轉換爲字符串放入temp中,最後一個數字表示十進制

   itoa(i,temp,2);   //按二進制方式轉換 

長整型(long)

   ltoa(l,temp,10);

2、從其它包含字符串的變量中獲取指向該字符串的指針

CString變量

str = "2008北京奧運";

buf = (LPSTR)(LPCTSTR)str; 

 

BSTR類型的_variant_t變量

v1 = (_bstr_t)"程序員";

buf = _com_util::ConvertBSTRToString((_bstr_t)v1);

3、字符串轉換爲其它數據類型

strcpy(temp,"123"); 

短整型(int)

   i = atoi(temp); 

長整型(long)

   l = atol(temp); 

浮點(double)

   d = atof(temp);

4、其它數據類型轉換到CString

   使用CString的成員函數Format來轉換,如:

整數(int)

   str.Format("%d",i); 

浮點數(float)

   str.Format("%f",i); 

字符串指針(char *)等已經被CString構造函數支持的數據類型能夠直接賦值

   str = username;

5、BSTR、_bstr_t與CComBSTR

CComBSTR、_bstr_t是對BSTR的封裝,BSTR是指向字符串的32位指針。

char *轉換到BSTR能夠這樣: 

BSTR b=_com_util::ConvertStringToBSTR("數據");  

//使用前須要加上頭文件comutil.h

反之可使用char *p=_com_util::ConvertBSTRToString(b);

6、VARIANT 、_variant_t 與 COleVariant

   VARIANT的結構能夠參考頭文件VC98\Include\OAIDL.H中關於結構體tagVARIANT的定義。對於VARIANT變量的賦值：首先給vt成員賦值，指明數據類型，再對聯合結構中相同數據類型的變量賦值，舉個例子：

VARIANT va;

int a=2001;

va.vt=VT_I4;  //指明整型數據

va.lVal=a;   //賦值

  對於不立刻賦值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);進行初始化,其本質是將vt設置爲VT_EMPTY,下表咱們列舉vt與經常使用數據的對應關係:

unsigned char bVal;   VT_UI1 

short iVal;           VT_I2 

long lVal;            VT_I4 

float fltVal;         VT_R4 

double dblVal;        VT_R8 

VARIANT_BOOL boolVal; VT_BOOL 

SCODE scode;          VT_ERROR 

CY cyVal;             VT_CY 

DATE date;             VT_DATE 

BSTR bstrVal;          VT_BSTR 

IUnknown FAR* punkVal; VT_UNKNOWN 

IDispatch FAR* pdispVal; VT_DISPATCH 

SAFEARRAY FAR* parray;   VT_ARRAY|* 

unsigned char FAR* pbVal; VT_BYREF|VT_UI1 

short FAR* piVal;       VT_BYREF|VT_I2 

long FAR* plVal;        VT_BYREF|VT_I4 

float FAR* pfltVal;     VT_BYREF|VT_R4 

double FAR* pdblVal;    VT_BYREF|VT_R8 

VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL 

SCODE FAR* pscode;      VT_BYREF|VT_ERROR 

CY FAR* pcyVal;         VT_BYREF|VT_CY 

DATE FAR* pdate;        VT_BYREF|VT_DATE 

BSTR FAR* pbstrVal;     VT_BYREF|VT_BSTR 

IUnknown FAR* FAR* ppunkVal;   VT_BYREF|VT_UNKNOWN 

IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH 

SAFEARRAY FAR* FAR* pparray;   VT_ARRAY|* 

VARIANT FAR* pvarVal;          VT_BYREF|VT_VARIANT 

void FAR* byref;               VT_BYREF 

_variant_t是VARIANT的封裝類，其賦值可使用強制類型轉換，其構造函數會自動處理這些數據類型。

如：

long l=222;

ing i=100;

_variant_t lVal(l);

lVal = (long)i;

COleVariant的使用與_variant_t的方法基本同樣，請參考以下例子：

COleVariant v3 = "字符串", v4 = (long)1999;

CString str =(BSTR)v3.pbstrVal;

long i = v4.lVal;

7、其它

   對消息的處理中咱們常常須要將WPARAM或LPARAM等32位數據(DWORD)分解成兩個16位數據(WORD),

如：

LPARAM lParam;

WORD loValue = LOWORD(lParam);  //取低16位

WORD hiValue = HIWORD(lParam);  //取高16位 

對於16位的數據(WORD)咱們能夠用一樣的方法分解成高低兩個8位數據(BYTE),

如:

WORD wValue;

BYTE loValue = LOBYTE(wValue);  //取低8位

BYTE hiValue = HIBYTE(wValue);  //取高8位 

如何將CString類型的變量賦給char*類型的變量

一、GetBuffer函數：

使用CString::GetBuffer函數。

char *p; 

CString str="hello"; 

p=str.GetBuffer(str.GetLength()); 

str.ReleaseBuffer();

將CString轉換成char * 時

CString str("aaaaaaa");

strcpy(str.GetBuffer(10),"aa");

str.ReleaseBuffer();

當咱們須要字符數組時調用GetBuffer(int n),其中n爲咱們須要的字符數組的長度.使用完成後必定要立刻調用ReleaseBuffer();

還有很重要的一點就是,在能使用const char *的地方,就不要使用char *

二、memcpy： 

CString mCS=_T("cxl"); 

char mch[20]; 

memcpy(mch,mCS,20); 

三、用LPCTSTR強制轉換： 儘可能不使用

char *ch; 

CString str; 

ch=(LPSTR)(LPCTSTR)str; 

CString str = "good";

char *tmp;

sprintf(tmp,"%s",(LPTSTR)(LPCTSTR)str); 

四、

CString Msg; 

Msg=Msg+"abc"; 

LPTSTR lpsz; 

lpsz = new TCHAR[Msg.GetLength()+1]; 

_tcscpy(lpsz, Msg); 

char * psz; 

strcpy(psz,lpsz); 

CString類向const char *轉換

char a[100];

CString str("aaaaaa");

strncpy(a,(LPCTSTR)str,sizeof(a));

或:

strncpy(a,str,sizeof(a));   

   以上兩種用法都是正確地. 由於strncpy的第二個參數類型爲const char *.因此編譯器會自動將CString類轉換成const char *.

CString轉LPCTSTR (const char *)

CString cStr;

const char *lpctStr=(LPCTSTR)cStr;

LPCTSTR轉CString

LPCTSTR lpctStr;

CString cStr=lpctStr;

將char*類型的變量賦給CString型的變量能夠直接賦值，如： 

   CString myString = "This is a test"; 

也可如： CString s1("Tom");

將CString類型的變量賦給char[]類型(字符串)的變量

一、sprintf()函數

CString str = "good";

char tmp[200] ;

sprintf(tmp, "%s",(LPCSTR)str); 

(LPCSTR)str這種強制轉換至關於(LPTSTR)(LPCTSTR)str 

CString類的變量須要轉換爲(char*)的時,使用(LPTSTR)(LPCTSTR)str 

    然而LPCTSTR是const char *,也就是說，獲得的字符串是不可寫的！將其強制轉換成LPTSTR去掉const，是極爲危險的！一不留神就會完蛋！要獲得char *,應該用GetBuffer()或GetBufferSetLength()，用完後再調用ReleaseBuffer()。

二、strcpy()函數

CString str;

char c[256];

strcpy(c, str); 

char mychar[1024];

CString source="Hello";

strcpy((char*)&mychar,(LPCTSTR)source); 

關於CString的使用

一、指定 CString 形參

   對於大多數須要字符串參數的函數，最好將函數原型中的形參指定爲一個指向字符(LPCTSTR)而非 CString 的const指針。

   當將形參指定爲指向字符的const指針時，可將指針傳遞到 TCHAR 數組（如字符串 ["hi there"]）或傳遞到 CString 對象。

   CString對象將自動轉換成LPCTSTR。任何可以使用LPCTSTR的地方也可以使用 CString對象。

二、若是某個形參將不會被修改，則也將該參數指定爲常數字符串引用（即const CString&）。若是函數要修改該字符串，則刪除const修飾符。若是須要默認爲空值，則將其初始化爲空字符串 [""]，以下所示：

void AddCustomer(const CString& name,const CString& address,const CString& comment = "" ); 

三、對於大多數函數結果，按值返回 CString 對象便可。

串的基本運算

   對於串的基本運算，不少高級語言均提供了相應的運算符或標準的庫函數來實現。爲敘述方便，先定義幾個相關的變量：

  char s1[20]="dir/bin/appl",

       s2[20]="file.asm",

       s3[30],*p;

  int result;

  下面以C語言中串運算介紹串的基本運算 

一、求串長

    int strlen(char *s);    //求串s的長度

  【例】printf("%d",strlen(s1));  //輸出s1的串長12

二、串複製

  char *strcpy(char *to,*from)；

  //將from串複製到to串中，並返回to開始處指針

  【例】strcpy(s3,s1); //s3="dir/bin/appl",s1串不變

三、聯接

  char *strcat(char *to,char *from);//將from串複製到to串的末尾，

                   //並返回to串開始處的指針

  【例】strcat(s3,"/");  //s3="dir/bin/appl/"

    strcat(s3,s2);  //s3="dir/bin/appl/file.asm"

四、串比較

  int strcmp(char *s1,char *s2);//比較s1和s2的大小，

  //當s1<s二、s1>s2和s1=s2時，分別返回小於0、大於0和等於0的值 

  【例】result=strcmp("baker","Baker");  //result>0

      result=strcmp("12","12");   //result=0

      result=strcmp("Joe","joseph") //result<0

五、字符定位

  char *strchr(char *s,char c);//找c在字符串s中第一次出現的位置，

                //若找到，則返回該位置，不然返回NULL

  【例】p=strchr(s2,'.');   //p指向"file"以後的位置

if(p) strcpy(p,".cpp");  //s2="file.cpp" 

 注意：

  ①上述操做是最基本的，其中後4個操做還有變種形式：strncpy，strncath和strnchr。

  ②其它的串操做見C的<string.h>。在不一樣的高級語言中，對串運算的種類及符號都不盡相同

  ③其他的串操做通常可由這些基本操做組合而成

  【例】求子串的操做可以下實現：

  void substr(char *sub,char *s,int pos,int len){

    //s和sub是字符數組，用sub返回串s的第pos個字符起長度爲len的子串

    //其中0<=pos<=strlen(s)-1,且數組sub至少可容納len+1個字符。

    if (pos<0||pos>strlen(s)-1||len<0)

      Error("parameter error!");

    strncpy(sub,&s[pos],len);   //從s[pos]起復制至多len個字符到sub

 

*************************

c++ 字符類型總結

1.區別wchar_t,char,WCHAR

  ANSI：即char，可用字符串處理函數：strcat( ),strcpy( ), strlen( )等以str打頭的函數。

  UNICODE：wchar_t是Unicode字符的數據類型，它實際定義在裏：

  typedef unsigned short wchar_t;

  另外，在頭文件中有這樣的定義：typedef wchar_t WCHAR; 因此WCHAR實際就是wchar_t。

  wchar_t可用字符串處理函數：wcscat(),wcscpy(),wcslen()等以wcs打頭的函數。爲了讓編譯器識別Unicode字符串，必須以在前面加一個「L」,例如: wchar_t *szTest=L"This is a Unicode string.";

2.TCHAR

  在C語言裏面提供了_UNICODE宏（有下劃線），在Windows裏面提供了UNICODE宏（無下劃線），只要定了_UNICODE宏和UNICODE宏，系統就會自動切換到UNICODE版本，不然，系統按照ANSI的方式進行編譯和運行。只定義了宏並不能實現自動的轉換，還須要一系列的字符定義支持。

  1． TCHAR

  若是定義了UNICODE宏則TCHAR被定義爲wchar_t。

  typedef wchar_t TCHAR;

  不然TCHAR被定義爲char typedef char TCHAR;

  2． LPTSTR

  若是定義了UNICODE宏則LPTSTR被定義爲LPWSTR。

  typedef LPTSTR LPWSTR;

  不然TCHAR被定義爲char typedef LPTSTR LPSTR;

  說明：在使用字符串常量的時候須要使用_TEXT(「MyStr」)或_T("")來支持系統的自動轉換。

3.BSTR

    BSTR是一個帶長度前綴的字符串,主要由操做系統來管理的,因此要用api.主要用來和VB打交道的(VB裏的string就是指它)要操做它的API函數有不少.好比sysAllocString,SysFreeString等等.

   vc裏封裝它的類如_bstr_t,及ATL中的CComBSTR等.

    一個BSTR由頭部和字符串組成，頭部包含了字符串的長度信息，字符串中能夠包含嵌入的 null 值。

    BSTR是以指針的形式進行傳遞的。(指針是一個變量，包含另一個變量的內存地址，而不是數據。) BSTR是Unicode的，即每一個字符須要兩個字節。BSTR一般以兩字節的 null 字符結束。 wstr是寬字符，以雙字節表示一個字符 bstr是爲了與原先的basic字符兼容，它的最前面的4個字節爲其長度，以'\0'結束.

4.更進一步的字符串以及其指針的類型定義

   因爲Win32API文檔的函數列表使用函數的經常使用名字 ( 如， "SetWindowText")，全部的字符串都是用TCHAR來定義的。（除了XP中引入的只適用於Unicode的API）。下面列出一些經常使用的typedefs，你能夠在msdn中看到他們。

type       Meaning in MBCS builds      Meaning in Unicode builds 

WCHAR       wchar_t                         wchar_t 

LPSTR       char*                           char* 

LPCSTR      const char*                     const char* 

LPWSTR      wchar_t*                        wchar_t* 

LPCWSTR     wchar_t*                        wchar_t* 

TCHAR       TCHAR                           char wchar_t 

LPTSTR      TCHAR*                          TCHAR* 

LPCTSTR     const TCHAR*                    const TCHAR* 

5.相互轉換

(1) char*轉換成CString

若將char*轉換成CString，除了直接賦值外，還可以使用CString::Format進行。如：

char chArray[] = "This is a test";

char * p = "This is a test";

或

LPSTR p = "This is a test";

或在已定義Unicode應的用程序中

TCHAR * p = _T("This is a test");

或

LPTSTR p = _T("This is a test");

CString theString = chArray;

theString.Format(_T("%s"), chArray);

theString = p;

(2) CString轉換成char*

  若將CString類轉換成char*(LPSTR)類型，常使用下列三種方法：

1，使用強制轉換。如：

CString theString( "This is a test" );

LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString; 

2，使用strcpy。如：

CString theString( "This is a test" );

LPTSTR lpsz = new TCHAR[theString.GetLength()+1];

_tcscpy(lpsz, theString);

須要說明的是，strcpy(或可移值Unicode/MBCS的_tcscpy)的第二個參數是 const wchar_t* (Unicode)或const char* (ANSI)，系統編譯器將會自動對其進行轉換。

3，使用CString::GetBuffer。如：

CString s(_T("This is a test "));

LPTSTR p = s.GetBuffer();

// 在這裏添加使用p的代碼

if(p != NULL) *p = _T('\0');

s.ReleaseBuffer();

// 使用完後及時釋放，以便能使用其它的CString成員函數

(3) BSTR轉換成char*

方法一 ，使用ConvertBSTRToString。例如：

#include

#pragma comment(lib, "comsupp.lib")

int _tmain(int argc, _TCHAR* argv[])

{

    BSTR bstrText = ::SysAllocString(L"Test");

    char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);

    SysFreeString(bstrText); // 用完釋放

    delete[] lpszText2;

    return 0;

} 

 

方法二，使用_bstr_t的賦值運算符重載。例如：

   _bstr_t b = bstrText;

   char* lpszText2 = b;

 

 

(4) char*轉換成BSTR

方法一，使用SysAllocString等API函數。例如：

BSTR bstrText = ::SysAllocString(L"Test");

BSTR bstrText = ::SysAllocStringLen(L"Test",4);

BSTR bstrText = ::SysAllocStringByteLen("Test",4);

方法二，使用COleVariant或_variant_t。例如：

//COleVariant strVar("This is a test");

_variant_t strVar("This is a test");

BSTR bstrText = strVar.bstrVal;

方法三，使用_bstr_t，這是一種最簡單的方法。例如：

BSTR bstrText = _bstr_t("This is a test");

方法四，使用CComBSTR。例如：

BSTR bstrText = CComBSTR("This is a test");

或

CComBSTR bstr("This is a test");

BSTR bstrText = bstr.m_str;

方法五，使用ConvertStringToBSTR。例如：

char* lpszText = "Test";

BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);

(5) CString轉換成BSTR

一般是經過使用CStringT::AllocSysString來實現。例如：

CString str("This is a test");

BSTR bstrText = str.AllocSysString();

…

SysFreeString(bstrText); // 用完釋放 

(6) BSTR轉換成CString

通常可按下列方法進行：

BSTR bstrText = ::SysAllocString(L"Test");

CStringA str;

str.Empty();

str = bstrText; 或  CStringA str(bstrText);

(7) ANSI、Unicode和寬字符之間的轉換

  一，使用MultiByteToWideChar將ANSI字符轉換成Unicode字符，

        用WideCharToMultiByte將Unicode字符轉換成ANSI字符。

 二，使用「_T」將ANSI轉換成「通常」類型字符串，使用「L」將ANSI轉換成 Unicode，而在託管C++環境中還可以使用S將ANSI字符串轉換成String*對象。

如：

TCHAR tstr[] = _T("this is a test");

wchar_t wszStr[] = L"This is a test";

String* str = S」This is a test」;

三，使用ATL 7.0的轉換宏和類。ATL7.0在原有3.0基礎上完善和增長了許多字符串轉換宏以及提供相應的類，它具備如圖3所示的統一形式：

其中，第一個C表示「類」，以便於ATL 3.0宏相區別，第二個C表示常量，2表示「to」，EX表示要開闢必定大小的緩衝。SourceType和DestinationType能夠是A、 T、W和OLE，其含義分別是ANSI、Unicode、「通常」類型和OLE字符串。

  如，CA2CT就是將ANSI轉換成通常類型的字符串常量。

下面是一些示例代碼：

LPTSTR tstr= CA2TEX<16>("this is a test");

LPCTSTR tcstr= CA2CT("this is a test");

wchar_t wszStr[] = L"This is a test";

char* chstr = CW2A(wszStr);