文章目錄
1. string
其實就是basic_string。
using string = basic_string<char, char_traits<char>, allocator<char>>;
2. System::String
暫時忽略
3. BSTR
typedef WCHAR OLECHAR;
typedef OLECHAR* BSTR;
typedef BSTR* LPBSTR;
在C/C++中，字符串通常採用“以0結束的字符數組”來表示，而在Visual Basic中，字符串則採用“字符數組加長度前綴的方法”來表示。
A BSTR (Basic string or binary string) is a string data type that is used by COM.
BSTR由3個成員組成：
- Length prefix，4字節，不包括終止符
- unicode string，可包含0
- Terminator，0x0000(WCHAR)
上面的定義在以前的mac中不兼容。
根據定義，BSTR是個指針，指向unicode string，而不是長度前綴。這段空間是用COM申請的，下面的用法是錯誤的：
BSTR MyBstr = L"I am a happy BSTR";
雖然可以編譯鏈接，但它沒有長度前綴。正確的用法是下面這樣：
#include <iostream>
#include <comdef.h> // or WTypes.h
int main()
{
BSTR bstrMyStr = SysAllocString(L"hello");
wprintf(L"%s\n",bstrMyStr);
SysFreeString(bstrMyStr);
system("pause");
return 0;
}
這是涉及中文等寬字節字符時，COM方法會出問題。
4. _bstr_t
COM中一共提供了兩個類來對BSTR進行封裝，一個是編譯器提供的COM支持類：_bstr_t，另一個則是ATL庫提供的包裹類CComBSTR。
_bstr_t的封裝層次較低，它更適合作爲轉換頭，提供char、wchar_t類型到BSTR類型之間的轉換。
它的構造函數很多，內部封裝了SysAllocString和SysFreeString來分配和釋放內存，還會涉及淺拷貝、_variant_t類等，需要查詢msdn。
_variant_t類封裝了VARIANT數據類型，管理資源申請和釋放，調用 VariantInit和VariantClear函數。
定義位於頭文件comutil.h，和庫comsuppw.lib（或者comsuppwd.lib），當然直接包含comdef頭文件即可。
它的賦值運算符會返回BSTR地址，慎用。
官方示例：
// _bstr_t_Assign.cpp
#include <comdef.h>
#include <stdio.h>
int main()
{
// creates a _bstr_t wrapper
_bstr_t bstrWrapper;
// creates BSTR and attaches to it
bstrWrapper = "some text";
wprintf_s(L"bstrWrapper = %s\n",
static_cast<wchar_t*>(bstrWrapper));
//"some text"
// bstrWrapper releases its BSTR
BSTR bstr = bstrWrapper.Detach();
wprintf_s(L"bstrWrapper = %s\n",
static_cast<wchar_t*>(bstrWrapper));
// "(null)"
// "some text"
wprintf_s(L"bstr = %s\n", bstr);
bstrWrapper.Attach(SysAllocString(OLESTR("SysAllocedString")));
wprintf_s(L"bstrWrapper = %s\n",
static_cast<wchar_t*>(bstrWrapper));
// "SysAllocedString"
// assign a BSTR to our _bstr_t
bstrWrapper.Assign(bstr);
wprintf_s(L"bstrWrapper = %s\n",
static_cast<wchar_t*>(bstrWrapper));
// "some text"
// done with BSTR, do manual cleanup
SysFreeString(bstr);
// resuse bstr
bstr= SysAllocString(OLESTR("Yet another string"));
// two wrappers, one BSTR
_bstr_t bstrWrapper2 = bstrWrapper;
*bstrWrapper.GetAddress() = bstr;
// bstrWrapper and bstrWrapper2 do still point to BSTR
bstr = 0;
wprintf_s(L"bstrWrapper = %s\n",
static_cast<wchar_t*>(bstrWrapper));
// "Yet another string"
wprintf_s(L"bstrWrapper2 = %s\n",
static_cast<wchar_t*>(bstrWrapper2));
// "some text"
// new value into BSTR
_snwprintf_s(bstrWrapper.GetBSTR(), 100, bstrWrapper.length(),
L"changing BSTR");
wprintf_s(L"bstrWrapper = %s\n",
static_cast<wchar_t*>(bstrWrapper));
// "changing BSTR"
wprintf_s(L"bstrWrapper2 = %s\n",
static_cast<wchar_t*>(bstrWrapper2));
// "some text"
}
注意
3點：
- 內部採用引用計數來管理字符串
- 構造或操作的過程是有可能拋出異常
- 在調用Detach脫離BSTR字符串之後，是需要手動調用SysFreeString來釋放內存的，否則會造成內存泄露問題。
5. CComBSTR
頭文件：atlbase.h
CComBSTR對BSTR（成員m_str）的封裝層次更高，如果要操作BSTR，建議使用CComBSTR。
Do not pass an ordinary wide-character string to this method. The compiler cannot catch the error and run time errors will occur.
部分函數成功則返回HRESULT類型S_OK。
轉換成ANSI：
// _bstr_t_Assign.cpp
#include <atlbase.h>
#include <iostream>
int main()
{
// Declare a CComBSTR object. Although the argument is ANSI,
// the constructor converts it into UNICODE.
CComBSTR bstrMyString("Hello World");
// Convert the string into an ANSI string
CW2A szMyString(bstrMyString);
std::cout << szMyString << std::endl;
system("pause");
return 0;
}
正確的返回方法：
// The wrong way to do it
BSTR * MyBadFunction()
{
// Create the CComBSTR object
CComBSTR bstrString(L"Hello World");
// Convert the string to uppercase
HRESULT hr;
hr = bstrString.ToUpper();
// Return a pointer to the BSTR. ** Bad thing to do **
return &bstrString;
}
// The correct way to do it
HRESULT MyGoodFunction(/*[out]*/ BSTR* bstrStringPtr)
{
// Create the CComBSTR object
CComBSTR bstrString(L"Hello World");
// Convert the string to uppercase
HRESULT hr;
hr = bstrString.ToUpper();
if (hr != S_OK)
return hr;
// Return a copy of the string.
return bstrString.CopyTo(bstrStringPtr);
}
注意
不要在循環中Append()，這種情況CString更合適。
不要用SysFreeString手動釋放CComBSTR。
小心下面這樣的內存泄漏問題。傳給out參數時，應該調用一下Empty釋放m_str，但如果是_in_out
CComBSTR bstrLeak(L"Initialized");
// bstrLeak.Empty();
HRESULT hr = MyGoodFunction(&bstrLeak);
6. CString
頭文件：atlstr.h，父類是CSimpleString。
它是基於引用計數的，可以使用成員函數LockBuffer()將引用計數置爲-1，鎖定狀態下，既不能增加引用，也不能指向其它緩衝區。Unlock會將引用計數置爲1.
CString內部也是VB風格字符串，當然和BSTR一樣也支持C風格函數。
CStringA aCString = "A string";
char myString[256];
strcpy(myString, (LPCSTR)aCString);
// T style
CString theString(_T("This is a test"));
int sizeOfString = (theString.GetLength() + 1);
LPTSTR lpsz = new TCHAR[sizeOfString];
_tcscpy_s(lpsz, sizeOfString, theString);
操作方法：
- GetBuffer()獲得指針
- Do Something， like writing…
- ReleaseBuffer()，更新狀態，比如長度
GetBuffer的參數和當前類型有關，如果是W版，參數就是word數。
7. 轉換
7.1 Converting from char *
// convert_from_char.cpp
// compile with: /clr /link comsuppw.lib
#include <iostream>
#include <stdlib.h>
#include <string>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
// Create and display a C style string, and then use it
// to create different kinds of strings.
char *orig = "Hello, World!";
cout << orig << " (char *)" << endl;
// newsize describes the length of the
// wchar_t string called wcstring in terms of the number
// of wide characters, not the number of bytes.
size_t newsize = strlen(orig) + 1;
// The following creates a buffer large enough to contain
// the exact number of characters in the original string
// in the new format. If you want to add more characters
// to the end of the string, increase the value of newsize
// to increase the size of the buffer.
wchar_t * wcstring = new wchar_t[newsize];
// Convert char* string to a wchar_t* string.
size_t convertedChars = 0;
mbstowcs_s(&convertedChars, wcstring, newsize, orig, _TRUNCATE);
// Display the result and indicate the type of string that it is.
wcout << wcstring << _T(" (wchar_t *)") << endl;
// Convert the C style string to a _bstr_t string.
_bstr_t bstrt(orig);
// Append the type of string to the new string
// and then display the result.
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert the C style string to a CComBSTR string.
CComBSTR ccombstr(orig);
if (ccombstr.Append(_T(" (CComBSTR)")) == S_OK)
{
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert the C style string to a CStringA and display it.
CStringA cstringa(orig);
cstringa += " (CStringA)";
cout << cstringa << endl;
// Convert the C style string to a CStringW and display it.
CStringW cstring(orig);
cstring += " (CStringW)";
// To display a CStringW correctly, use wcout and cast cstring
// to (LPCTSTR).
wcout << (LPCTSTR)cstring << endl;
// Convert the C style string to a basic_string and display it.
string basicstring(orig);
basicstring += " (basic_string)";
cout << basicstring << endl;
// Convert the C style string to a System::String and display it.
String ^systemstring = gcnew String(orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
7.2 Converting from wchar_t *
// convert_from_wchar_t.cpp
// compile with: /clr /link comsuppw.lib
#include <iostream>
#include <stdlib.h>
#include <string>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
// Create a string of wide characters, display it, and then
// use this string to create other types of strings.
wchar_t *orig = _T("Hello, World!");
wcout << orig << _T(" (wchar_t *)") << endl;
// Convert the wchar_t string to a char* string. Record
// the length of the original string and add 1 to it to
// account for the terminating null character.
size_t origsize = wcslen(orig) + 1;
size_t convertedChars = 0;
// Use a multibyte string to append the type of string
// to the new string before displaying the result.
char strConcat[] = " (char *)";
size_t strConcatsize = (strlen( strConcat ) + 1)*2;
// Allocate two bytes in the multibyte output string for every wide
// character in the input string (including a wide character
// null). Because a multibyte character can be one or two bytes,
// you should allot two bytes for each character. Having extra
// space for the new string is not an error, but having
// insufficient space is a potential security problem.
const size_t newsize = origsize*2;
// The new string will contain a converted copy of the original
// string plus the type of string appended to it.
char *nstring = new char[newsize+strConcatsize];
// Put a copy of the converted string into nstring
wcstombs_s(&convertedChars, nstring, newsize, orig, _TRUNCATE);
// append the type of string to the new string.
_mbscat_s((unsigned char*)nstring, newsize+strConcatsize, (unsigned char*)strConcat);
// Display the result.
cout << nstring << endl;
// Convert a wchar_t to a _bstr_t string and display it.
_bstr_t bstrt(orig);
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert the wchar_t string to a BSTR wide character string
// by using the ATL CComBSTR wrapper class for BSTR strings.
// Then display the result.
CComBSTR ccombstr(orig);
if (ccombstr.Append(_T(" (CComBSTR)")) == S_OK)
{
// CW2A converts the string in ccombstr to a multibyte
// string in printstr, used here for display output.
CW2A printstr(ccombstr);
cout << printstr << endl;
// The following line of code is an easier way to
// display wide character strings:
wcout << (LPCTSTR) ccombstr << endl;
}
// Convert a wide wchar_t string to a multibyte CStringA,
// append the type of string to it, and display the result.
CStringA cstringa(orig);
cstringa += " (CStringA)";
cout << cstringa << endl;
// Convert a wide character wchar_t string to a wide
// character CStringW string and append the type of string to it
CStringW cstring(orig);
cstring += " (CStringW)";
// To display a CStringW correctly, use wcout and cast cstring
// to (LPCTSTR).
wcout << (LPCTSTR)cstring << endl;
// Convert the wide character wchar_t string to a
// basic_string, append the type of string to it, and
// display the result.
wstring basicstring(orig);
basicstring += _T(" (basic_string)");
wcout << basicstring << endl;
// Convert a wide character wchar_t string to a
// System::String string, append the type of string to it,
// and display the result.
String ^systemstring = gcnew String(orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
7.3 Converting from _bstr_t
// convert_from_bstr_t.cpp
// compile with: /clr /link comsuppw.lib
#include <iostream>
#include <stdlib.h>
#include <string>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
// Create a _bstr_t string, display the result, and indicate the
// type of string that it is.
_bstr_t orig("Hello, World!");
wcout << orig << " (_bstr_t)" << endl;
// Convert the wide character _bstr_t string to a C style
// string. To be safe, allocate two bytes for each character
// in the char* string, including the terminating null.
const size_t newsize = (orig.length()+1)*2;
char *nstring = new char[newsize];
// Uses the _bstr_t operator (char *) to obtain a null
// terminated string from the _bstr_t object for
// nstring.
strcpy_s(nstring, newsize, (char *)orig);
strcat_s(nstring, newsize, " (char *)");
cout << nstring << endl;
// Prepare the type of string to append to the result.
wchar_t strConcat[] = _T(" (wchar_t *)");
size_t strConcatLen = wcslen(strConcat) + 1;
// Convert a _bstr_t to a wchar_t* string.
const size_t widesize = orig.length()+ strConcatLen;
wchar_t *wcstring = new wchar_t[newsize];
wcscpy_s(wcstring, widesize, (wchar_t *)orig);
wcscat_s(wcstring, widesize, strConcat);
wcout << wcstring << endl;
// Convert a _bstr_t string to a CComBSTR string.
CComBSTR ccombstr((char *)orig);
if (ccombstr.Append(_T(" (CComBSTR)")) == S_OK)
{
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert a _bstr_t to a CStringA string.
CStringA cstringa(orig.GetBSTR());
cstringa += " (CStringA)";
cout << cstringa << endl;
// Convert a _bstr_t to a CStringW string.
CStringW cstring(orig.GetBSTR());
cstring += " (CStringW)";
// To display a cstring correctly, use wcout and
// "cast" the cstring to (LPCTSTR).
wcout << (LPCTSTR)cstring << endl;
// Convert the _bstr_t to a basic_string.
string basicstring((char *)orig);
basicstring += " (basic_string)";
cout << basicstring << endl;
// Convert the _bstr_t to a System::String.
String ^systemstring = gcnew String((char *)orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
7.4 Converting from CComBSTR
// convert_from_ccombstr.cpp
// compile with: /clr /link comsuppw.lib
#include <iostream>
#include <stdlib.h>
#include <string>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "vcclr.h"
using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;
int main()
{
// Create and initialize a BSTR string by using a CComBSTR object.
CComBSTR orig("Hello, World!");
// Convert the BSTR into a multibyte string, display the result,
// and indicate the type of string that it is.
CW2A printstr(orig);
cout << printstr << " (CComBSTR)" << endl;
// Convert a wide character CComBSTR string to a
// regular multibyte char* string. Allocate enough space
// in the new string for the largest possible result,
// including space for a terminating null.
const size_t newsize = (orig.Length()+1)*2;
char *nstring = new char[newsize];
// Create a string conversion object, copy the result to
// the new char* string, and display the result.
CW2A tmpstr1(orig);
strcpy_s(nstring, newsize, tmpstr1);
cout << nstring << " (char *)" << endl;
// Prepare the type of string to append to the result.
wchar_t strConcat[] = _T(" (wchar_t *)");
size_t strConcatLen = wcslen(strConcat) + 1;
// Convert a wide character CComBSTR string to a wchar_t*.
// The code first determines the length of the converted string
// plus the length of the appended type of string, then
// prepares the final wchar_t string for display.
const size_t widesize = orig.Length()+ strConcatLen;
wchar_t *wcstring = new wchar_t[widesize];
wcscpy_s(wcstring, widesize, orig);
wcscat_s(wcstring, widesize, strConcat);
// Display the result. Unlike CStringW, a wchar_t does not need
// a cast to (LPCTSTR) with wcout.
wcout << wcstring << endl;
// Convert a wide character CComBSTR to a wide character _bstr_t,
// append the type of string to it, and display the result.
_bstr_t bstrt(orig);
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert a wide character CComBSTR to a multibyte CStringA,
// append the type of string to it, and display the result.
CStringA cstringa(orig);
cstringa += " (CStringA)";
cout << cstringa << endl;
// Convert a wide character CComBSTR to a wide character CStringW.
CStringW cstring(orig);
cstring += " (CStringW)";
// To display a cstring correctly, use wcout and cast cstring
// to (LPCTSTR).
wcout << (LPCTSTR)cstring << endl;
// Convert a wide character CComBSTR to a wide character
// basic_string.
wstring basicstring(orig);
basicstring += _T(" (basic_string)");
wcout << basicstring << endl;
// Convert a wide character CComBSTR to a System::String.
String ^systemstring = gcnew String(orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
7.5 Converting from CString
// convert_from_cstring.cpp
// compile with: /clr /link comsuppw.lib
#include <iostream>
#include <stdlib.h>
#include <string>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
// Set up a multibyte CStringA string.
CStringA origa("Hello, World!");
cout << origa << " (CStringA)" << endl;
// Set up a wide character CStringW string.
CStringW origw("Hello, World!");
wcout << (LPCTSTR)origw << _T(" (CStringW)") << endl;
// Convert to a char* string from CStringA string
// and display the result.
const size_t newsizea = (origa.GetLength() + 1);
char *nstringa = new char[newsizea];
strcpy_s(nstringa, newsizea, origa);
cout << nstringa << " (char *)" << endl;
// Convert to a char* string from a wide character
// CStringW string. To be safe, we allocate two bytes for each
// character in the original string, including the terminating
// null.
const size_t newsizew = (origw.GetLength() + 1)*2;
char *nstringw = new char[newsizew];
size_t convertedCharsw = 0;
wcstombs_s(&convertedCharsw, nstringw, newsizew, origw, _TRUNCATE );
cout << nstringw << " (char *)" << endl;
// Convert to a wchar_t* from CStringA
size_t convertedCharsa = 0;
wchar_t *wcstring = new wchar_t[newsizea];
mbstowcs_s(&convertedCharsa, wcstring, newsizea, origa, _TRUNCATE);
wcout << wcstring << _T(" (wchar_t *)") << endl;
// Convert to a wide character wchar_t* string from
// a wide character CStringW string.
wchar_t *n2stringw = new wchar_t[newsizew];
wcscpy_s( n2stringw, newsizew, origw );
wcout << n2stringw << _T(" (wchar_t *)") << endl;
// Convert to a wide character _bstr_t string from
// a multibyte CStringA string.
_bstr_t bstrt(origa);
bstrt += _T(" (_bstr_t)");
wcout << bstrt << endl;
// Convert to a wide character _bstr_t string from
// a wide character CStringW string.
bstr_t bstrtw(origw);
bstrtw += " (_bstr_t)";
wcout << bstrtw << endl;
// Convert to a wide character CComBSTR string from
// a multibyte character CStringA string.
CComBSTR ccombstr(origa);
if (ccombstr.Append(_T(" (CComBSTR)")) == S_OK)
{
// Convert the wide character string to multibyte
// for printing.
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert to a wide character CComBSTR string from
// a wide character CStringW string.
CComBSTR ccombstrw(origw);
// Append the type of string to it, and display the result.
if (ccombstrw.Append(_T(" (CComBSTR)")) == S_OK)
{
CW2A printstrw(ccombstrw);
wcout << printstrw << endl;
}
// Convert a multibyte character CStringA to a
// multibyte version of a basic_string string.
string basicstring(origa);
basicstring += " (basic_string)";
cout << basicstring << endl;
// Convert a wide character CStringW to a
// wide character version of a basic_string
// string.
wstring basicstringw(origw);
basicstringw += _T(" (basic_string)");
wcout << basicstringw << endl;
// Convert a multibyte character CStringA to a
// System::String.
String ^systemstring = gcnew String(origa);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
// Convert a wide character CStringW to a
// System::String.
String ^systemstringw = gcnew String(origw);
systemstringw += " (System::String)";
Console::WriteLine("{0}", systemstringw);
delete systemstringw;
}
7.6 Converting from basic_string
// convert_from_basic_string.cpp
// compile with: /clr /link comsuppw.lib
#include <iostream>
#include <stdlib.h>
#include <string>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
// Set up a basic_string string.
string orig("Hello, World!");
cout << orig << " (basic_string)" << endl;
// Convert a wide character basic_string string to a multibyte char*
// string. To be safe, we allocate two bytes for each character
// in the original string, including the terminating null.
const size_t newsize = (strlen(orig.c_str()) + 1)*2;
char *nstring = new char[newsize];
strcpy_s(nstring, newsize, orig.c_str());
cout << nstring << " (char *)" << endl;
// Convert a basic_string string to a wide character
// wchar_t* string. You must first convert to a char*
// for this to work.
const size_t newsizew = strlen(orig.c_str()) + 1;
size_t convertedChars = 0;
wchar_t *wcstring = new wchar_t[newsizew];
mbstowcs_s(&convertedChars, wcstring, newsizew, orig.c_str(), _TRUNCATE);
wcout << wcstring << _T(" (wchar_t *)") << endl;
// Convert a basic_string string to a wide character
// _bstr_t string.
_bstr_t bstrt(orig.c_str());
bstrt += _T(" (_bstr_t)");
wcout << bstrt << endl;
// Convert a basic_string string to a wide character
// CComBSTR string.
CComBSTR ccombstr(orig.c_str());
if (ccombstr.Append(_T(" (CComBSTR)")) == S_OK)
{
// Make a multibyte version of the CComBSTR string
// and display the result.
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert a basic_string string into a multibyte
// CStringA string.
CStringA cstring(orig.c_str());
cstring += " (CStringA)";
cout << cstring << endl;
// Convert a basic_string string into a wide
// character CStringW string.
CStringW cstringw(orig.c_str());
cstringw += _T(" (CStringW)");
wcout << (LPCTSTR)cstringw << endl;
// Convert a basic_string string to a System::String
String ^systemstring = gcnew String(orig.c_str());
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
7.7 Converting from System::String
// convert_from_system_string.cpp
// compile with: /clr /link comsuppw.lib
#include <iostream>
#include <stdlib.h>
#include <string>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "vcclr.h"
using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;
int main()
{
// Set up a System::String and display the result.
String ^orig = gcnew String("Hello, World!");
Console::WriteLine("{0} (System::String)", orig);
// Obtain a pointer to the System::String in order to
// first lock memory into place, so that the
// Garbage Collector (GC) cannot move that object
// while we call native functions.
pin_ptr<const wchar_t> wch = PtrToStringChars(orig);
// Make a copy of the System::String as a multibyte
// char* string. Allocate two bytes in the multibyte
// output string for every wide character in the input
// string, including space for a terminating null.
size_t origsize = wcslen(wch) + 1;
const size_t newsize = origsize*2;
size_t convertedChars = 0;
char *nstring = new char[newsize];
wcstombs_s(&convertedChars, nstring, newsize, wch, _TRUNCATE);
cout << nstring << " (char *)" << endl;
// Convert a wide character System::String to a
// wide character wchar_t* string.
const size_t newsizew = origsize;
wchar_t *wcstring = new wchar_t[newsizew];
wcscpy_s(wcstring, newsizew, wch);
wcout << wcstring << _T(" (wchar_t *)") << endl;
// Convert a wide character System::String to a
// wide character _bstr_t string.
_bstr_t bstrt(wch);
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert a wide character System::String
// to a wide character CComBSTR string.
CComBSTR ccombstr(wch);
if (ccombstr.Append(_T(" (CComBSTR)")) == S_OK)
{
// Make a multibyte copy of the CComBSTR string
// and display the result.
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert a wide character System::String to
// a multibyte CStringA string.
CStringA cstring(wch);
cstring += " (CStringA)";
cout << cstring << endl;
// Convert a wide character System::String to
// a wide character CStringW string.
CStringW cstringw(wch);
cstringw += " (CStringW)";
wcout << (LPCTSTR)cstringw << endl;
// Convert a wide character System::String to
// a wide character basic_string.
wstring basicstring(wch);
basicstring += _T(" (basic_string)");
wcout << basicstring << endl;
delete orig;
}