Converting std::string to a const WCHAR *string required by a GDI+ parameter

Question

Short version I am using unicode. I am attempting to use a std::string, to a function that requires a const WCHAR string; DrawString(const WCHAR, ...

I compile with GCC. Everything is unicode, I have specified.

I have been trying to convert a string, into a wchar_t*. The purpose is so that I can output using a GDI+ function, its parameters require it so.

Here is how I have outputted string literals, no problems, debugs fine, works fine. http://msdn.microsoft.com/en-us/library/ms535991%28v=vs.85%29.aspx for reference why:

// works fine
wchar_t* wcBuff;
wcBuff = (wchar_t*)L"Some text here.\0"; 
AddString(wcBuff, wcslen(wcBuff), &gFontFamilyInfo, FontStyleBold, 20, ptOrg_Controls, &strFormat_Info);

Now this is what I have been trying, all day, and a side note: my conversion function works fine, it is not an issue, nor creating one.

// problems
string s = "Level " + convert::intToString(6) + "\0"; 

// try 1 - Segfault
wchar_t* wcBuff = new wchar_t[s.length() + 1]; 
copy(s.begin(), s.end(), wcBuff);

// random tries, compiles, but access violations (my conversion function here has worked other places, do not know for sure here.
wchar_t* wcBuff;
wstring wstr = convert::stringToWideChar(s);
wstring strvalue = convert::stringToWideChar(s);           
wcBuff = (wchar_t*)strvalue.c_str(); 
wcBuff = (wchar_t*)wstr.c_str();

wstring foo;
foo.assign(s.begin(), s.end());
wcBuff = (wchar_t*)foo.c_str();

Everything compiles, but then presents problems. Some runtime errors as soon as it reaches that point. Others access violations and segfaults. Some compiles and debugs no problem, but the strings output constantly changes with random characters.

Any ideas?

Answer 1

#include <string>

int main() {

   // Can use convenient wstring
   std::wstring wstr = L"My wide string";

   // When you need a whar_t* just do this
   const wchar_t* s = wstr.c_str();

  // unicode form of strcpy
  wchar_t buf[100] = {0};
  wcscpy (buf,s);

  // And if you want to convert from string to wstring
  std::string thin = "I only take up one byte per character!";
  std::wstring wide(thin.begin(), thin.end());

   return 0;
}

Answer 2

(this is not really an answer, but it's too big for a comment)

Try 1: you didn't null-terminate the string

Try 2: can't comment without seeing the conversion function. Remove the casts.

Try 3: Remove the casts, should be OK.

In all cases use wchar_t const *wcBuff. If "Try 3" fails then it means you have a bug somewhere else in your code, that is showing up here. Try to produce a MCVE. You should be able to get it down to about 10-20 lines.

Even if you manage to write the correct code for what you're intending, this is a fairly naive conversion as it doesn't handle characters outside the 0-127 range properly. You need to think about whether that is what you want, or whether you want to do a UTF-8 conversion, etc.

In Windows you can use MultiByteToWideChar.

Answer 3

I first get my data into a wstring. Like this:

(Converting from string):

  std::string sString = "This is my string text";
  std::wstring str1(sString.begin(), sString.end());

(Converting from int):

wstring str1 = std::to_wstring(BirthDate);

Then, I use it in GDI+ Command like this:

graphics.DrawString(str1.c_str(), -1,
    &font, PointF(10, 5), &st);

Answer 4

First thing first. GDI+ is a C++ library. It uses Microsoft C++ ABI. Microsoft C++ ABI is wildly incompatible with gcc so you might just forget about using it. You can try to use WinAPI or any other library that uses C calling conventions.

Now for the wstring question. wchar_t is 32 bits wide in gcc, but Windows APIs require it to be 16 bits wide. You cannot use any native Windows call that requires wchar_t.

You can use -fshort-wchar command line option in gcc, that would make wchar_t 16 bits wide and you will regain compatibility with Windows APIs, but lose compatibility with libc, so no library functions that act on wchar_t for you. std::wstring will probably work as it's header-only, but wprintf or wscpy or all other compiled stuff won't.

None of this is detected at compile time, as the only things gcc sees are header files. It cannot tell whether corresponding libraries are compiled with 16-bit wchar_t or 32-bit wchar_t.

You can use uint16_t when you need to pass an array of wchar_t to a Windows function. If you can use C++11, it has char16_t that you can use too. Here's an example that should work with Basic Multilingual Plane characters:

std::wstring myLittleNiceWstring; 
...
std::vector<uint16_t> myUglyCompatibilityString;
std::copy(myLittleNiceWstring.begin(),
          myLittleNiceWstring.end(),
          std::back_inserter(myUglyCompatibilityString));
myUglyCompatibilityString.push_back(0);

UglyWindowsAPI(static_cast<WCHAR*>(myUglyCompatibilityString.data());

If you have non-BMP characters, you need to convert UTF32 to UTF16 rather than just copy characters with std::copy. You can use libiconv for that or write a conversion routine yourself (it's rather simple) or just boorow some code from the internet.

It is my opinion that Windows-centric development with GCC is rather difficult because of this and other issues. You can use gcc as long as you stick to POSIX-ish APIs.