Well, it depends from the type of the STL string. If it’s a std::wstring, you can simply invoke its c_str method:
// DoSomethingApi(PCWSTR pszText, ... other stuff ...)
std::wstring someText = L"Connie";
// Invoke the wstring::c_str() method to pass the wstring
// as PCWSTR parameter to a Windows API:
DoSomethingApi(someText.c_str(), /* other parameters */);
The wstring::c_str method returns a pointer to a read-onlyC-style null-terminated “wide” (i.e. UTF-16 on Windows) string, which is exactly what a PCWSTR parameter expects.
If it’s a std::string, then you have to consider the encoding used by it. For example, if it’s a UTF-8-encoded string, you can first convert from UTF-8 to UTF-16, and then pass the UTF-16 equivalent std::wstring object to the Windows API invoking the c_str method as shown above.
If the std::string stores text encoded in a different way, you could still use the MultiByteToWideChar API to convert from that encoding to UTF-16, and pass the result std::wstring to the PCWSTR parameter invoking the wstring::c_str method, as well.
Exploring what’s under the hood of a common Windows SDK C/C++ typedef, including an interesting code annotation.
If you have done some Windows native programming in C or C++, you would have almost certainly found some apparently weird types, like PCWSTR.
So, what does PCWSTR mean?
Well, to understand its meaning, let’s split it up into smaller pieces:
The initial P stands for pointer. So, this is a pointer to something.
The following C stands for const. So, this is a pointer to something that cannot be modified.
The remaining WSTR part stands for WCHAR STRing, and represents the target of the pointer.
So, a PCWSTR is a pointer to a constant (i.e. read-only) WCHAR string.
The WSTR or “WCHAR string” part needs some elaboration. Basically, WCHAR is a typedef for wchar_t. So, a WSTR or WCHAR string basically means a C-style NUL-terminated string made by an array of wchar_ts. In other words, this is a Unicode UTF-16 C-style NUL-terminated string.
Putting all these pieces of information together, a PCWSTR is basically a pointer (P) to a constant (C) NUL-terminated C-style wchar_t Unicode UTF-16 string (WSTR).
Decoding the PCWSTR typedef
This PCWSTR definition can be translated in the following C/C++ typedef:
typedef const WCHAR* PCWSTR;
// NOTE:
// WCHAR is a typedef for wchar_t
Some C++ coding guidelines, like Google’s, suggest avoiding those Windows SDK typedefs like PCWSTR in your own C++ code, and instead “keeping as close as you can to the underlying C++ types”:
Windows defines many of its own synonyms for primitive types, such as DWORD, HANDLE, etc. It is perfectly acceptable, and encouraged, that you use these types when calling Windows API functions. Even so, keep as close as you can to the underlying C++ types. For example, use const TCHAR * instead of LPCTSTR.
Google C++ Style Guide – Windows Code Section
In other words, following those guidelines, you should use the explicit and more verbose “const WCHAR*” or “const wchar_t*”, instead of the PCWSTR typedef.
Don’t Miss the Code Annotation
However, if you take a look at the actual typedef in the Windows SDK headers, you’ll see that the definition of PCWSTR is something like this:
// PCWSTR definition in the <winnt.h> Windows SDK header
typedef _Null_terminated_ CONST WCHAR *LPCWSTR, *PCWSTR;
The important thing to note here is the _Null_terminated_ part, which is a C/C++ code annotation that specifies that the WCHAR array pointed to must be null-terminated. This is something useful when you run Code Analysis on your C/C++ Windows native code, as it can help spotting subtle bugs, like pointing to non-null-terminated character arrays by mistake.
So, in this case, if you follow C++ coding styles like Google’s, and keep as close as possible to the underlying C++ types, you miss the important code annotation part.
An Equivalent Type with Historical Roots: LPCWSTR
As a side note, as you can see from the above typedef from the <winnt.h> Windows SDK header, there is a totally equivalent type to PCWSTR: it’s LPCWSTR, the difference being in the additional initial “L“. This “L” probably means “long“, and should be thought of as attached to the “P”as in “LP”. So, basically, this should probably mean something like “long pointer”. I’m not entirely sure, but I think this is something from the 16-bit Windows era, when the memory was somehow segmented and there were “near” pointers and “far” or “long” pointers. But, as I said, I’m not entirely sure, as I started programming in C++ for Windows 95, enjoying the 32-bit era.
Giovanni Dicanio's Blog 