一． VC常用數據類型列表
二． 常用數據類型轉化
2.1數學類型變量與字符串相互轉換
2.2 CString及string,char *與其他數據類型的轉換和操作
●CString,string,char*的綜合比較
●數學類型與CString相互轉化
●CString與char*相互轉換舉例
●CString 與 BSTR 型轉換
●VARIANT 型轉化成 CString 型
2.3 BSTR、_bstr_t與CComBSTR
2.4 VARIANT 、_variant_t 與 COleVariant
附錄CString及字符串轉及操作詳解
參考書籍:CSDN,<<MFC深入淺出(Second Edit)>>
一．VC常用數據類型列表
|
|
Type |
Default Size |
Description |
|
基 礎 類 型
全 是 小 寫
|
說明:這些基礎數據類型對於MFC還是API都是被支持的 |
||
|
boolean |
unsigned 8 bit , |
取值TRUE/FALSE |
|
|
byte |
unsigned 8 bit, |
整數,輸出按字符輸出 |
|
|
char |
unsigned 8 bit, |
字符 |
|
|
double |
signed 64 bit |
浮點型 |
|
|
float |
signed32 bit |
浮點型 |
|
|
handle_t |
|
Primitive handle type |
|
|
hyper |
signed 64 bit |
整型 |
|
|
int |
signed 32 bit |
整型 |
|
|
long |
signed 32 bit |
整型 |
|
|
short |
signed 16 bit |
整型 |
|
|
small |
signed 8 bit |
整型 |
|
|
void * |
32-bit |
指向未知類型的指針 |
|
|
wchar_t |
unsigned 16 bit |
16位字符,比char可容納更多的字符 |
|
|
|
|
|
|
|
Win32 API 常 用 數 據 類 型
全 大 寫 |
說明: 這些Win32API支持的簡單數據類型主要是用來定義函數返回值，消息參數，結構成員。這類數據類型大致可以分爲五大類：字符型、布爾型、整型、指針型和句柄型（?）. 總共大概有100多種不同的類型， |
||
|
BOOL/BOOLEAN |
8bit,TRUE/FALSE |
布爾型 |
|
|
BYTE |
unsigned 8 bit |
|
|
|
BSTR CComBSTR _bstr_t |
32 bit |
BSTR是指向字符串的32位指針 是對BSTR的封裝 是對BSTR的封裝 |
|
|
CHAR |
8 bit |
(ANSI）字符類型 |
|
|
COLORREF |
32 bit |
RGB顏色值 整型 |
|
|
DWORD |
unsigned 32 bit |
整型 |
|
|
FLOAT |
float型 |
float型 |
|
|
HANDLE |
|
Object句柄 |
|
|
HBITMAP |
|
bitmap句柄 |
|
|
HBRUSH |
|
brush句柄 |
|
|
HCURSOR |
|
cursor句柄 |
|
|
HDC |
|
設備上下文句柄 |
|
|
HFILE |
|
OpenFile打開的File句柄 |
|
|
HFONT |
|
font句柄 |
|
|
HHOOK |
|
hook句柄 |
|
|
HKEY |
|
註冊表鍵句柄 |
|
|
HPEN |
|
pen句柄 |
|
|
HWND |
|
window句柄 |
|
|
INT |
-------- |
-------- |
|
|
LONG |
-------- |
--------- |
|
|
LONGLONG |
|
64位帶符號整型 |
|
|
LPARAM |
32 bit |
消息參數 |
|
|
LPBOOL |
|
BOOL型指針 |
|
|
LPBYTE |
|
BYTE型指針 |
|
|
LPCOLOREF |
|
COLORREF型指針 |
|
|
LPCSTR/LPSTR/PCSTR |
|
指向8位（ANSI）字符串類型指針 |
|
|
LPCWSTR/LPWSTR/PCWSTR |
|
指向16位Unicode字符串類型 |
|
|
LPCTSTR/LPTSTR/PCTSTR |
|
指向一8位或16位字符串類型指針 |
|
|
LPVOID |
|
指向一個未指定類型的32位指針 |
|
|
LPDWORD |
|
指向一個DWORD型指針 |
|
|
其他相似類型: LPHANDLE、LPINT、LPLONG、LPWORD、LPRESULT PBOOL、PBOOLEAN、PBYTE、PCHAR、PDWORD、PFLOAT、PHANDLE、PINT、PLONG、PSHORT…… 說明:(1)在16位系統中 LP爲16bit,P爲8bit,在32位系統中都是32bit(此時等價) (2)LPCSTR等 中的C指Const,T表示TCHAR模式即可以工作在ANSI下也可UNICODE |
|||
|
SHORT |
usigned |
整型 |
|
|
其他UCHAR、UINT、ULONG、ULONGLONG、USHORT爲無符號相應類型 |
|||
|
TBYTE |
|
WCHAR型或者CHAR型 |
|
|
TCHAR |
|
ANSI與unicode均可 |
|
|
VARIANT _variant_t COleVariant |
|
一個結構體參考OAIDL.H _variant_t是VARIANT的封裝類 COleVariant也是VARIANT的封裝類 |
|
|
|
|
|
|
|
|
|
|
|
|
WNDPROC |
|
指向一個窗口過程的32位指針 |
|
|
WCHAR |
|
16位Unicode字符型 |
|
|
WORD |
|
16位無符號整型 |
|
|
WPARAM |
|
消息參數 |
|
|
MFC 獨有 數據 類型 |
下面兩個數據類型是微軟基礎類庫中獨有的數據類型 |
||
|
POSITION |
標記集合中一個元素的位置的值,被MFC中的集合類所使用 |
||
|
LPCRECT |
指向一個RECT結構體常量（不能修改）的32位指針 |
||
|
CString |
其實是MFC中的一個類 |
||
|
|
|
|
|
說明:
(1)-------表示省略
(2)1Byte=8Bit,
字與機器有關,在8位系統中:字=1字節,16位系統中,1字=2字節，32位中:1字=4字節,
64位中1字=8字節.不要搞混這些概念.
二．常用數據類型轉化及操作
2．1 數學類型變量與字符串相互轉換(這些函數都在STDLIB.H裏)
（1）將數學類型轉換爲字符串可以用以下一些函數:
舉例: _CRTIMP char * __cdecl _itoa(int, char *, int);//這是一個將數字轉換爲一個字符串類型的函數,最後一個int表示轉換的進制
如以下程序:
int iTyep=3;
char *szChar;
itoa(iType,szChar,2);
cout<<szChar;//輸出爲1010
類似函數列表:
_CRTIMP char * __cdecl _itoa(int, char *, int);//爲了完整性,也列在其中
_CRTIMP char * __cdecl _ultoa(unsigned long, char *, int);
_CRTIMP char * __cdecl _ltoa(long, char *, int);
_CRTIMP char * __cdecl _i64toa(__int64, char *, int);
_CRTIMP char * __cdecl _ui64toa(unsigned __int64, char *, int);
_CRTIMP wchar_t * __cdecl _i64tow(__int64, wchar_t *, int);
_CRTIMP wchar_t * __cdecl _ui64tow(unsigned __int64, wchar_t *, int);
_CRTIMP wchar_t * __cdecl _itow (int, wchar_t *, int);//轉換爲長字符串類型
_CRTIMP wchar_t * __cdecl _ltow (long, wchar_t *, int);
_CRTIMP wchar_t * __cdecl _ultow (unsigned long, wchar_t *, int);
還有很多,請自行研究
（2）將字符串類型轉換爲數學類型變量可以用以下一些函數:
舉例: _CRTIMP int __cdecl atoi(const char *);//參數一看就很明瞭
char *szChar=”88”;
int temp(0);
temp=atoi(szChar);
cout<<temp;
類似的函數列表:
_CRTIMP int __cdecl atoi(const char *);
_CRTIMP double __cdecl atof(const char *);
_CRTIMP long __cdecl atol(const char *);
_CRTIMP long double __cdecl _atold(const char *);
_CRTIMP __int64 __cdecl _atoi64(const char *);
_CRTIMP double __cdecl strtod(const char *, char **);//
_CRTIMP long __cdecl strtol(const char *, char **, int);//
_CRTIMP long double __cdecl _strtold(const char *, char **);
_CRTIMP unsigned long __cdecl strtoul(const char *, char **, int);
_CRTIMP double __cdecl wcstod(const wchar_t *, wchar_t **);//長字符串類型轉換爲數學類型
_CRTIMP long __cdecl wcstol(const wchar_t *, wchar_t **, int);
_CRTIMP unsigned long __cdecl wcstoul(const wchar_t *, wchar_t **, int);
_CRTIMP int __cdecl _wtoi(const wchar_t *);
_CRTIMP long __cdecl _wtol(const wchar_t *);
_CRTIMP __int64 __cdecl _wtoi64(const wchar_t *);
還有很多,請自行研究
2．2．CString及string,char *與其他數據類型的轉換和操作
（1）CString,string,char*的綜合比較（這部分CSDN上的作者joise的文章
<< CString,string,char*的綜合比較>>寫的很詳細,請大家在仔細閱讀他的文章.
地址: http://blog.csdn.net/joise/
或參考附錄:
(2)轉換:
●數學類型與CString相互轉化
數學類型轉化爲CString
可用Format函數,舉例:
CString s;
int i = 64;
s.Format("%d", i)
CString轉換爲數學類型:舉例CString strValue("1.234");
double dblValue;
dblValue = atof((LPCTSTR)strValue);
●CString與char*相互轉換舉例
CString strValue(“Hello”);
char *szValue;
szValue=strValue.GetBuffer(szValue);
也可用(LPSTR)(LPCTSTR)對CString// 進行強制轉換.
szValue=(LPSTR)(LPCTSTR)strValue;
反過來可直接賦值:
char *szChar=NULL;
CString strValue;
szChar=new char[10];
memset(szChar,0,10);
strcpy(szChar,”Hello”);
strValue=szChar;
●CString 與 BSTR 型轉換
CString 型轉化成 BSTR 型
當我們使用 ActiveX 控件編程時，經常需要用到將某個值表示成 BSTR 類型.BSTR 是一種記數字符串，Intel平臺上的寬字符串（Unicode），並且可以包含嵌入的 NULL 字符。
可以調用 CString 對象的 AllocSysString 方法將 CString 轉化成 BSTR：
CString str;
str = .....; // whatever
BSTR bStr = str.AllocSysString();
BSTR型轉換爲CString
如果你在 UNICODE 模式下編譯代碼，你可以簡單地寫成：
CString convert(BSTR bStr)
{
if(bStr == NULL)
return CString(_T(""));
CString s(bStr); // in UNICODE mode
return s;
}
如果是 ANSI 模式
CString convert(BSTR b)
{
CString s;
if(b == NULL)
return s; // empty for NULL BSTR
#ifdef UNICODE
s = b;
#else
LPSTR p = s.GetBuffer(SysStringLen(b) + 1);
::WideCharToMultiByte(CP_ACP, // ANSI Code Page
0, // no flags
b, // source widechar string
-1, // assume NUL-terminated
p, // target buffer
SysStringLen(b)+1, // target buffer length
NULL, // use system default char
NULL); // don''t care if default used
s.ReleaseBuffer();
#endif
return s;
}
●VARIANT 型轉化成 CString 型
VARIANT 類型經常用來給 COM 對象傳遞參數，或者接收從 COM 對象返回的值。你也能自己編寫返回 VARIANT 類型的方法，函數返回什麼類型 依賴可能（並且常常）方法的輸入參數（比如，在自動化操作中，依賴與你調用哪個方法。IDispatch::Invoke 可能返回（通過其一個參數）一個 包含有BYTE、WORD、float、double、date、BSTR 等等 VARIANT 類型的結果，（詳見 MSDN 上的 VARIANT 結構的定義）。在下面的例子中，假設 類型是一個BSTR的變體，也就是說在串中的值是通過 bsrtVal 來引用，其優點是在 ANSI 應用中，有一個構造函數會把 LPCWCHAR 引用的值轉換爲一個 CString（見 BSTR-to-CString 部分）。在 Unicode 模式中，將成爲標準的 CString 構造函數，參見對缺省::WideCharToMultiByte 轉換的告誡，以及你覺得是否可以接受（大多數情況下，你會滿意的）。VARIANT vaData;
vaData = m_com.YourMethodHere();
ASSERT(vaData.vt == VT_BSTR);
CString strData(vaData.bstrVal);
你還可以根據 vt 域的不同來建立更通用的轉換例程。爲此你可能會考慮：
CString VariantToString(VARIANT * va)
{
CString s;
switch(va->vt)
{ /* vt */
case VT_BSTR:
return CString(vaData->bstrVal);
case VT_BSTR | VT_BYREF:
return CString(*vaData->pbstrVal);
case VT_I4:
s.Format(_T("%d"), va->lVal);
return s;
case VT_I4 | VT_BYREF:
s.Format(_T("%d"), *va->plVal);
case VT_R8:
s.Format(_T("%f"), va->dblVal);
return s;
... 剩下的類型轉換由讀者自己完成
default:
ASSERT(FALSE); // unknown VARIANT type (this ASSERT is optional)
return CString("");
} /* vt */
}
2．3 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);
2．4(引)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;
posted on 2005-11-13 00:30 痛並快樂着 閱讀(1555) 評論(4) 編輯 收藏 引用 網摘 所屬分類: Visual C++
<script type="text/javascript">//Sys.WebForms.PageRequestManager._initialize('AjaxHolder$scriptmanager1', document.getElementById('Form1'));Sys.WebForms.PageRequestManager.getInstance()._updateControls(['tAjaxHolder$UpdatePanel1'], [], [], 90);//</script>
評論
VC++.NET中字符串之間的轉換一、BSTR、LPSTR和LPWSTR
在Visual C++.NET的所有編程方式中，我們常常要用到這樣的一些基本字符串類型，如BSTR、LPSTR和LPWSTR等。之所以出現類似上述的這些數據類型，是因爲不同編程語言之間的數據交換以及對ANSI、Unicode和多字節字符集(MBCS)的支持。
那麼什麼是BSTR、LPSTR以及LPWSTR呢？
BSTR(Basic STRing，Basic字符串)是一個OLECHAR*類型的Unicode字符串。它被描述成一個與自動化相兼容的類型。由於操作系統提供相應的 API函數(如SysAllocString)來管理它以及一些默認的調度代碼，因此BSTR實際上就是一個COM字符串，但它卻在自動化技術以外的多種場合下得到廣泛使用。圖1描述了BSTR的結構，其中DWORD值是字符串中實際所佔用的字節數，且它的值是字符串中Unicode字符的兩倍。
LPSTR和LPWSTR是Win32和VC++所使用的一種字符串數據類型。LPSTR被定義成是一個指向以NULL(‘/0’)結尾的8位ANSI 字符數組指針，而LPWSTR是一個指向以NULL結尾的16位雙字節字符數組指針。在VC++中，還有類似的字符串類型，如LPTSTR、 LPCTSTR等，它們的含義如圖2所示。
例如，LPCTSTR是指“long pointer to a constant generic string”，表示“一個指向一般字符串常量的長指針類型”，與C/C++的const char*相映射，而LPTSTR映射爲 char*。
一般地，還有下列類型定義：
#ifdef UNICODE
typedef LPWSTR LPTSTR;
typedef LPCWSTR LPCTSTR;
#else
typedef LPSTR LPTSTR;
typedef LPCSTR LPCTSTR;
#endif
二、CString、CStringA 和 CStringW
Visual C++.NET中將CStringT作爲ATL和MFC的共享的“一般”字符串類，它有CString、CStringA和CStringW三種形式，分別操作不同字符類型的字符串。這些字符類型是TCHAR、char和wchar_t。TCHAR在Unicode平臺中等同於WCHAR(16位 Unicode字符)，在ANSI中等價於char。wchar_t通常定義爲unsigned short。由於CString在MFC應用程序中經常用到，這裏不再重複。
三、VARIANT、COleVariant 和_variant_t
在OLE、ActiveX和COM中，VARIANT數據類型提供了一種非常有效的機制，由於它既包含了數據本身，也包含了數據的類型，因而它可以實現各種不同的自動化數據的傳輸。下面讓我們來看看OAIDL.H文件中VARIANT定義的一個簡化版：
struct tagVARIANT {
VARTYPE vt;
union {
short iVal; // VT_I2.
long lVal; // VT_I4.
float fltVal; // VT_R4.
double dblVal; // VT_R8.
DATE date; // VT_DATE.
BSTR bstrVal; // VT_BSTR.
…
short * piVal; // VT_BYREF|VT_I2.
long * plVal; // VT_BYREF|VT_I4.
float * pfltVal; // VT_BYREF|VT_R4.
double * pdblVal; // VT_BYREF|VT_R8.
DATE * pdate; // VT_BYREF|VT_DATE.
BSTR * pbstrVal; // VT_BYREF|VT_BSTR.
};
};
顯然，VARIANT類型是一個C結構，它包含了一個類型成員vt、一些保留字節以及一個大的union類型。例如，如果vt爲VT_I2，那麼我們可以從iVal中讀出VARIANT的值。同樣，當給一個VARIANT變量賦值時，也要先指明其類型。例如：
VARIANT va;
:: VariantInit(&va); // 初始化
int a = 2002;
va.vt = VT_I4; // 指明long數據類型
va.lVal = a; // 賦值
爲了方便處理VARIANT類型的變量，Windows還提供了這樣一些非常有用的函數：
VariantInit —— 將變量初始化爲VT_EMPTY；
VariantClear —— 消除並初始化VARIANT；
VariantChangeType —— 改變VARIANT的類型；
VariantCopy —— 釋放與目標VARIANT相連的內存並複製源VARIANT。
COleVariant類是對VARIANT結構的封裝。它的構造函數具有極爲強大大的功能，當對象構造時首先調用VariantInit進行初始化，然後根據參數中的標準類型調用相應的構造函數，並使用VariantCopy進行轉換賦值操作，當VARIANT對象不在有效範圍時，它的析構函數就會被自動調用，由於析構函數調用了VariantClear，因而相應的內存就會被自動清除。除此之外，COleVariant的賦值操作符在與VARIANT類型轉換中爲我們提供極大的方便。例如下面的代碼：
COleVariant v1("This is a test"); // 直接構造
COleVariant v2 = "This is a test";
// 結果是VT_BSTR類型，值爲"This is a test"
COleVariant v3((long)2002);
COleVariant v4 = (long)2002;
// 結果是VT_I4類型，值爲2002
_variant_t是一個用於COM的VARIANT類，它的功能與COleVariant相似。不過在Visual C++.NET的MFC應用程序中使用時需要在代碼文件前面添加下列兩句：
#include "comutil.h"
#pragma comment( lib, "comsupp.lib" )
四、CComBSTR和_bstr_t
CComBSTR是對BSTR數據類型封裝的一個ATL類，它的操作比較方便。例如：
CComBSTR bstr1;
bstr1 = "Bye"; // 直接賦值
OLECHAR* str = OLESTR("ta ta"); // 長度爲5的寬字符
CComBSTR bstr2(wcslen(str)); // 定義長度爲5
wcscpy(bstr2.m_str, str); // 將寬字符串複製到BSTR中
CComBSTR bstr3(5, OLESTR("Hello World"));
CComBSTR bstr4(5, "Hello World");
CComBSTR bstr5(OLESTR("Hey there"));
CComBSTR bstr6("Hey there");
CComBSTR bstr7(bstr6);
// 構造時複製，內容爲"Hey there"
_bstr_t是是C++對BSTR的封裝，它的構造和析構函數分別調用SysAllocString和SysFreeString函數，其他操作是借用BSTR API函數。與_variant_t相似，使用時也要添加comutil.h和comsupp.lib。
五、BSTR、char*和CString轉換
(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)類型，常常使用下列三種方法：
方法一，使用強制轉換。例如：
CString theString( "This is a test" );
LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;
方法二，使用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)，系統編譯器將會自動對其進行轉換。
方法三，使用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);
六、結語
幾乎所有的程序都要用到字符串，而Visual C++.NET由於功能強大、應用廣泛，因而字符串之間的轉換更爲頻繁。本文幾乎涉及到目前的所有轉換方法。當然對於.NET框架來說，還可使用Convert和Text類進行不同數據類型以及字符編碼之間的相互轉換。