Assigning a "const char*" to std::string is allowed, but assigning to std::wstring doesn't compile. Why?

Question

I assumed that std::wstring and std::string both provide more or less the same interface.

So I tried to enable unicode capabilities for our application

# ifdef APP_USE_UNICODE
    typedef std::wstring AppStringType;
# else
    typedef std::string  AppStringType;
# endif

However that gives me a lot of compile errors when -DAPP_USE_UNICODE is used.

It turned out, that the compiler chokes when a const char[] is assigned to std::wstring.

EDIT: improved example by removing the usage of literal "hello".

#include <string>

void myfunc(const char h[]) {
   string  s = h; // compiles OK
   wstring w = h; // compile Error
}

Why does it make such a difference?

Assigning a const char* to std::string is allowed, but assigning to std::wstring gives compile errors.

Shouldn't std::wstring provide the same interface as std::string? At least for such a basic operation as assignment?

(environment: gcc-4.4.1 on Ubuntu Karmic 32bit)

Answer 1

You should do:

#include <string>

int main() {
  const wchar_t h[] = L"hello";
  std::wstring w = h;
  return 0;
}

std::string is a typedef of std::basic_string<char>, while std::wstring is a typedef of std::basic_string<wchar_t>. As such, the 'equivalent' C-string of a wstring is an array of wchar_ts.

The 'L' in front of the string literal is to indicate that you are using a wide-char string constant.

Answer 2

you should use

#include <tchar.h>

tstring instead of wstring/string TCHAR* instead of char* and _T("hello") instead of "hello" or L"hello"

this will use the appropriate form of string+char, when _UNICODE is defined.

Answer 3

The relevant part of the string API is this constructor:

basic_string(const charT*);

For std::string, charT is char. For std::wstring it's wchar_t. So the reason it doesn't compile is that wstring doesn't have a char* constructor. Why doesn't wstring have a char* constructor?

There is no one unique way to convert a string of char to a string of wchar. What's the encoding used with the char string? Is it just 7 bit ASCII? Is it UTF-8? Is it UTF-7? Is it SHIFT-JIS? So I don't think it would entirely make sense for std::wstring to have an automatic conversion from char*, even though you could cover most cases. You can use:

w = std::wstring(h, h + sizeof(h) - 1);

which will convert each char in turn to wchar (except the NUL terminator), and in this example that's probably what you want. As int3 says though, if that's what you mean it's most likely better to use a wide string literal in the first place.

Answer 4

Small suggestion... Do not use "Unicode" strings under Linux (a.k.a. wide strings). std::string is perfectly fine and holds Unicode very well (UTF-8).

Most Linux API works with char * strings and most popular encoding is UTF-8.

So... Just don't bother yourself using wstring.

Answer 5

In addition to the other answers, you could use a trick from Microsoft's book (specifically, tchar.h), and write something like this:

# ifdef APP_USE_UNICODE
    typedef std::wstring AppStringType;
    #define _T(s) (L##s)
# else
    typedef std::string  AppStringType;
    #define _T(s) (s)
# endif

AppStringType foo = _T("hello world!");

(Note: my macro-fu is weak, and this is untested, but you get the idea.)

Answer 6

Looks like you can do something like this:

    #include <sstream>
    // ...
    std::wstringstream tmp;
    tmp << "hello world";
    std::wstring our_string =

Although for a more complex situation, you may want to break down and use mbstowcs

Answer 7

To convert from a multibyte encoding to a wide character encoding, take a look at the header <locale> and the type std::codecvt. The Dinkumware library has a class Dinkum::wstring_convert that makes performing such multibyte-to-wide conversions easier.

The function std::codecvt_byname allows one to find a codecvt instance for a particular named encoding. Unfortunately, discovering the names of the encodings (or locales) on your system is implementation-specific.