Как конвертировать wstring в строку?

Question

Как конвертировать wstring в строку?

Вопрос в том, как преобразовать строку в строку?

У меня есть следующий пример:

#include <string>
#include <iostream>

int main()
{
    std::wstring ws = L"Hello";
    std::string s( ws.begin(), ws.end() );

  //std::cout <<"std::string =     "<<s<<std::endl;
    std::wcout<<"std::wstring =    "<<ws<<std::endl;
    std::cout <<"std::string =     "<<s<<std::endl;
}

вывод с закомментированной строкой:

std::string =     Hello
std::wstring =    Hello
std::string =     Hello

но без только:

std::wstring =    Hello

Что-то не так в примере? Могу ли я сделать преобразование, как указано выше?

РЕДАКТИРОВАТЬ

Новый пример (с учетом некоторых ответов)

#include <string>
#include <iostream>
#include <sstream>
#include <locale>

int main()
{
    setlocale(LC_CTYPE, "");

    const std::wstring ws = L"Hello";
    const std::string s( ws.begin(), ws.end() );

    std::cout<<"std::string =     "<<s<<std::endl;
    std::wcout<<"std::wstring =    "<<ws<<std::endl;

    std::stringstream ss;
    ss << ws.c_str();
    std::cout<<"std::stringstream =     "<<ss.str()<<std::endl;
}

Выход:

std::string =     Hello
std::wstring =    Hello
std::stringstream =     0x860283c

поэтому поток строк нельзя использовать для преобразования wstring в строку.

274

c++ unicode stl wstring

Источник

user476681 26 янв '11 в 11:58

19 ответов

Решение

Как отметил Кубби в одном из комментариев, std::wstring_convert (C++11) предоставляет удобное простое решение (вам нужно #include<locale> а также <codecvt>):

wstring string_to_convert;

//setup converter
using convert_type = std::codecvt_utf8<wchar_t>;
std::wstring_convert<convert_type, wchar_t> converter;

//use converter (.to_bytes: wstr->str, .from_bytes: str->wstr)
std::string converted_str = converter.to_bytes( string_to_convert );

Я использовал комбинацию wcstombs и утомительное распределение / освобождение памяти, прежде чем я столкнулся с этим.

http://en.cppreference.com/w/cpp/locale/wstring_convert

обновление (2013.11.28)

Один лайнер можно сформулировать так (спасибо, Гусс, за ваш комментарий):

std::wstring str = std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes("some string");

Функции обертки можно сформулировать так: (Спасибо, ArmanSchwarz за комментарий)

wstring s2ws(const std::string& str)
{
    using convert_typeX = std::codecvt_utf8<wchar_t>;
    std::wstring_convert<convert_typeX, wchar_t> converterX;

    return converterX.from_bytes(str);
}

string ws2s(const std::wstring& wstr)
{
    using convert_typeX = std::codecvt_utf8<wchar_t>;
    std::wstring_convert<convert_typeX, wchar_t> converterX;

    return converterX.to_bytes(wstr);
}

Примечание: есть некоторые споры о том, string/wstring должны передаваться в функции как ссылки или как литералы (из-за C++11 и обновлений компилятора). Я оставлю решение человеку, осуществляющему, но это стоит знать.

Примечание: я использую std::codecvt_utf8 в приведенном выше коде, но если вы не используете UTF-8, вам нужно изменить его на соответствующую кодировку:

http://en.cppreference.com/w/cpp/header/codecvt

386

Источник

user1709725 22 авг '13 в 07:57

Решение от: http://forums.devshed.com/c-programming-42/wstring-to-string-444006.html

std::wstring wide( L"Wide" ); 
std::string str( wide.begin(), wide.end() );

// Will print no problemo!
std::cout << str << std::endl;

Помните, что здесь не происходит никакого преобразования набора символов. То, что это делает, это просто назначить каждую итерацию wchar_t к char усечённое преобразование. Он использует std:: string c'tor:

template< class InputIt >
basic_string( InputIt first, InputIt last,
              const Allocator& alloc = Allocator() );

Как указано в комментариях:

значения 0-127 идентичны практически во всех кодировках, поэтому усечение значений, которые меньше 127, приводит к одному и тому же тексту. Введите китайский иероглиф, и вы увидите провал.

-

Значения 128-255 кодовой страницы Windows 1252 (по умолчанию Windows English) и значения 128-255 Unicode в основном одинаковы, поэтому, если вы используете кодовую страницу, большинство из этих символов должны быть усечены до правильных значений. (Я полностью ожидал, что и õ будет работать, я знаю, что наш код на работе полагается на это для é, который я скоро исправлю)

И обратите внимание, что кодовые точки в диапазоне 0x80 - 0x9F в Win1252 не будет работать. Это включает €, œ, ž, Ÿ...

174

Источник

user139942 23 авг '12 в 18:18

Кодировка по умолчанию:
Windows UTF-16.
Linux UTF-8.
MacOS UTF-8.

Этот код имеет две формы для преобразования std:: string в std:: wstring и std:: wstring в std:: string. Если вы отрицаете # если определен WIN32, вы получите тот же результат.

1. std:: string to std:: wstring

• MultiByteToWideChar WinAPI

• _mbstowcs_s_l

#if defined WIN32
#include <windows.h>
#endif

std::wstring StringToWideString(std::string str)
{
    if (str.empty())
    {
        return std::wstring();
    }
    size_t len = str.length() + 1;
    std::wstring ret = std::wstring(len, 0);
#if defined WIN32
    int size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, &str[0], str.size(), &ret[0], len);
    ret.resize(size);
#else
    size_t size = 0;
    _locale_t lc = _create_locale(LC_ALL, "en_US.UTF-8");
    errno_t retval = _mbstowcs_s_l(&size, &ret[0], len, &str[0], _TRUNCATE, lc);
    _free_locale(lc);
    ret.resize(size - 1);
#endif
    return ret;
}

2. std:: wstring в std:: string

• WideCharToMultiByte WinAPI

• _wcstombs_s_l

std::string WidestringToString(std::wstring wstr)
{
    if (wstr.empty())
    {
        return std::string();
    }
#if defined WIN32
    int size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, &wstr[0], wstr.size(), NULL, 0, NULL, NULL);
    std::string ret = std::string(size, 0);
    WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, &wstr[0], wstr.size(), &ret[0], size, NULL, NULL);
#else
    size_t size = 0;
    _locale_t lc = _create_locale(LC_ALL, "en_US.UTF-8");
    errno_t err = _wcstombs_s_l(&size, NULL, 0, &wstr[0], _TRUNCATE, lc);
    std::string ret = std::string(size, 0);
    err = _wcstombs_s_l(&size, &ret[0], size, &wstr[0], _TRUNCATE, lc);
    _free_locale(lc);
    ret.resize(size - 1);
#endif
    return ret;
}

3. На windows нужно распечатать юникод, используя WinAPI.

• WriteConsole

#if defined _WIN32
    void WriteLineUnicode(std::string s)
    {
        std::wstring unicode = StringToWideString(s);
        WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), unicode.c_str(), unicode.length(), NULL, NULL);
        std::cout << std::endl;
    }

    void WriteUnicode(std::string s)
    {
        std::wstring unicode = StringToWideString(s);
        WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), unicode.c_str(), unicode.length(), NULL, NULL);
    }

    void WriteLineUnicode(std::wstring ws)
    {
        WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), ws.c_str(), ws.length(), NULL, NULL);
        std::cout << std::endl;
    }

    void WriteUnicode(std::wstring ws)
    {
        WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), ws.c_str(), ws.length(), NULL, NULL);
    }

4. По основной программе.

#if defined _WIN32
int wmain(int argc, WCHAR ** args)
#else
int main(int argc, CHAR ** args)
#endif
{
    std::string source = u8"ÜüΩωЙ你月曜日\naèéøÞǽлљΣæča";
    std::wstring wsource = L"ÜüΩωЙ你月曜日\naèéøÞǽлљΣæča";

    WriteLineUnicode(L"@" + StringToWideString(source) + L"@");
    WriteLineUnicode("@" + WidestringToString(wsource) + "@");
    return EXIT_SUCCESS;
}

5. Наконец, вам нужна мощная и полная поддержка символов Юникода в консоли. Я рекомендую ConEmu и установить в качестве терминала по умолчанию в Windows. Вам нужно подключить Visual Studio к ConEmu. Помните, что исполняемый файл Visual Studio - devenv.exe

Протестировано на Visual Studio 2017 с VC++; станд = C++17.

Результат

https://i.imgur.com/32EAG1B.png

17

Источник

user3158594 24 сен '18 в 23:13

Вместо того, чтобы включать в себя локаль и все эти причудливые вещи, если вы знаете, что FACT ваша строка конвертируемая, просто сделайте это:

#include <iostream>
#include <string>

using namespace std;

int main()
{
  wstring w(L"bla");
  string result;
  for(char x : w)
    result += x;

  cout << result << '\n';
}

Живой пример здесь

13

Источник

user1200540 21 июл '12 в 02:35

Помимо простого преобразования типов, вы также должны осознавать фактический формат строки.

При компиляции для многобайтового набора символов Visual Studio и Win API принимают UTF8 (на самом деле кодировка Windows, которая является Windows-28591).
При компиляции для набора символов Unicode Visual studio и Win API используют UTF16.

Итак, вы также должны преобразовать строку из формата UTF16 в формат UTF8, а не просто преобразовать в std::string.
Это станет необходимым при работе с многосимвольными форматами, такими как некоторые нелатинские языки.

Идея состоит в том, чтобы решить, что std::wstring всегда представляет UTF16.
А такжеstd::string всегда представляет UTF8.

Это не обеспечивается компилятором, это скорее хорошая политика. Обратите внимание на префиксы строк, которые я использую для определения UTF16 (L) и UTF8 (u8).

Для преобразования между двумя типами вы должны использовать: std:: codecvt_utf8_utf16

#include <string>

#include <codecvt>

int main()
{

    std::string original8 = u8"הלו";

    std::wstring original16 = L"הלו";

    //C++11 format converter
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert;

    //convert to UTF8 and std::string
    std::string utf8NativeString = convert.to_bytes(original16);

    std::wstring utf16NativeString = convert.from_bytes(original8);

    assert(utf8NativeString == original8);
    assert(utf16NativeString == original16);

    return 0;
}

8

Источник

user536086 02 янв '20 в 11:55

Есть две проблемы с кодом:

Преобразование в const std::string s( ws.begin(), ws.end() ); не требуется правильно сопоставлять широкие символы с их узким аналогом. Скорее всего, каждый широкий символ просто будет приведен к char,
Решение этой проблемы уже дано в ответе Кемом и включает narrow функция локали ctype фаска.
Вы пишете вывод для обоих std::cout а также std::wcout в той же программе. И то и другое cout а также wcout связаны с тем же потоком (stdout) и результаты использования одного и того же потока как байтово-ориентированного потока (как cout делает) и широко ориентированный поток (как wcout не) не определены.
Лучший вариант - избегать смешивания узких и широких выходных данных с одним и тем же (базовым) потоком. За stdout/cout/wcoutможно попробовать переключить ориентацию stdout при переключении между широким и узким выходом (или наоборот):
```
#include <iostream>
#include <stdio.h>
#include <wchar.h>

int main() {
    std::cout << "narrow" << std::endl;
    fwide(stdout, 1); // switch to wide
    std::wcout << L"wide" << std::endl;
    fwide(stdout, -1); // switch to narrow
    std::cout << "narrow" << std::endl;
    fwide(stdout, 1); // switch to wide
    std::wcout << L"wide" << std::endl;
}
```

8

Источник

user430719 26 янв '11 в 13:33

Я считаю, что официальный путь еще впереди codecvt аспекты (вам нужен какой-то перевод с учетом локали), как в

resultCode = use_facet<codecvt<char, wchar_t, ConversionState> >(locale).
  in(stateVar, scratchbuffer, scratchbufferEnd, from, to, toLimit, curPtr);

или что-то в этом роде, у меня нет рабочего кода. Но я не уверен, сколько людей в наши дни используют этот механизм, а сколько просто запрашивают указатели на память и позволяют ICU или какой-либо другой библиотеке обрабатывать мрачные детали.

8

Источник

user254252 26 янв '11 в 12:11

Если вы имеете дело с путями к файлам (как я часто делаю, когда обнаруживаю необходимость в wstring-to-string), вы можете использовать filesystem::path (начиная с C++17):

      #include <filesystem>

const std::wstring wPath = GetPath(); // some function that returns wstring
const std::string path = std::filesystem::path(wPath).string();

7

Источник

user126823 24 май '21 в 16:26

На момент написания этого ответа поисковая система Google номер один "преобразовать строку wstring" попадет на эту страницу. Мой ответ показывает, как преобразовать строку в wstring, хотя это не фактический вопрос, и я, вероятно, должен удалить этот ответ, но это считается плохой формой. Вы можете перейти к этому ответу Stackru, который теперь имеет более высокий рейтинг, чем эта страница.

Вот способ объединения строковых, wstring и смешанных строковых констант в wstring. Используйте класс wstringstream.

#include <sstream>

std::string narrow = "narrow";
std::wstring wide = "wide";

std::wstringstream cls;
cls << " abc " << narrow.c_str() << L" def " << wide.c_str();
std::wstring total= cls.str();

7

Источник

user364818 19 июл '11 в 22:48

Вы могли бы также просто использовать узкий метод фасета ctype напрямую:

#include #include #include #include встроенный std::string узкий (std::wstring const& text)
{
    std::locale const loc("");
    wchar_t const* from = text.c_str();
    std::size_t const len = text.size();
    буфер std::vector (len + 1);
    std:: use_facet> (loc).narrow (from, from + len, '_', & buffer [0]);
    return std::string (& buffer [0], & buffer [len]);
}

6

Источник

user139855 07 ноя '11 в 21:58

Я потратил много печальных дней, пытаясь придумать способ сделать это для C++17, который устарел. code_cvt аспекты, и это лучшее, что я смог придумать, объединив код из нескольких разных источников:

setlocale( LC_ALL, "en_US.UTF-8" ); //Invoked in main()

std::string wideToMultiByte( std::wstring const & wideString )
{
     std::string ret;
     std::string buff( MB_CUR_MAX, '\0' );

     for ( wchar_t const & wc : wideString )
     {
         int mbCharLen = std::wctomb( &buff[ 0 ], wc );

         if ( mbCharLen < 1 ) { break; }

         for ( int i = 0; i < mbCharLen; ++i ) 
         { 
             ret += buff[ i ]; 
         }
     }

     return ret;
 }

 std::wstring multiByteToWide( std::string const & multiByteString )
 {
     std::wstring ws( multiByteString.size(), L' ' );
     ws.resize( 
         std::mbstowcs( &ws[ 0 ], 
             multiByteString.c_str(), 
             multiByteString.size() ) );

     return ws;
 }

Я тестировал этот код в Windows 10, и, по крайней мере, для моих целей он работает нормально. Пожалуйста, не линчуйте меня, если это не учитывает некоторые безумные крайние случаи, с которыми вам, возможно, придется справиться, я уверен, что кто-то с большим опытом может улучшить это!:-)

Кроме того, кредит, причитающийся:

Адаптирован для wideToMultiByte()

Скопировано для multiByteToWide

6

Источник

user3277692 16 ноя '20 в 12:35

Это решение вдохновлено решением dk123, но использует зависящий от локали фасет codecvt. Результат находится в строке с кодировкой локали вместо utf8 (если она не установлена как локаль):

std::string w2s(const std::wstring &var)
{
   static std::locale loc("");
   auto &facet = std::use_facet<std::codecvt<wchar_t, char, std::mbstate_t>>(loc);
   return std::wstring_convert<std::remove_reference<decltype(facet)>::type, wchar_t>(&facet).to_bytes(var);
}

std::wstring s2w(const std::string &var)
{
   static std::locale loc("");
   auto &facet = std::use_facet<std::codecvt<wchar_t, char, std::mbstate_t>>(loc);
   return std::wstring_convert<std::remove_reference<decltype(facet)>::type, wchar_t>(&facet).from_bytes(var);
}

Я искал это, но я не могу найти это. Наконец, я обнаружил, что могу получить правильный фасет из std:: locale, используя функцию std::use_facet() с правильным именем типа. Надеюсь это поможет.

6

Источник

user2464169 27 апр '16 в 14:57

В моем случае я должен использовать многобайтовые символы (MBCS), и я хочу использовать std::string и std::wstring. И не могу использовать с ++11. Поэтому я использую mbstowcs и wcstombs.

Я делаю ту же функцию с использованием new, delete [], но это медленнее, чем это.

Это может помочь Как: конвертировать между различными типами строк

РЕДАКТИРОВАТЬ

Однако, в случае преобразования в строку wstring и исходную строку нет алфавита и многобайтовой строки, это не работает. Поэтому я изменяю wcstombs на WideCharToMultiByte.

#include <string>

std::wstring get_wstr_from_sz(const char* psz)
{
    //I think it's enough to my case
    wchar_t buf[0x400];
    wchar_t *pbuf = buf;
    size_t len = strlen(psz) + 1;

    if (len >= sizeof(buf) / sizeof(wchar_t))
    {
        pbuf = L"error";
    }
    else
    {
        size_t converted;
        mbstowcs_s(&converted, buf, psz, _TRUNCATE);
    }

    return std::wstring(pbuf);
}

std::string get_string_from_wsz(const wchar_t* pwsz)
{
    char buf[0x400];
    char *pbuf = buf;
    size_t len = wcslen(pwsz)*2 + 1;

    if (len >= sizeof(buf))
    {
        pbuf = "error";
    }
    else
    {
        size_t converted;
        wcstombs_s(&converted, buf, pwsz, _TRUNCATE);
    }

    return std::string(pbuf);
}

РЕДАКТИРОВАТЬ, чтобы использовать "MultiByteToWideChar" вместо "wcstombs"

#include <Windows.h>
#include <boost/shared_ptr.hpp>
#include "string_util.h"

std::wstring get_wstring_from_sz(const char* psz)
{
    int res;
    wchar_t buf[0x400];
    wchar_t *pbuf = buf;
    boost::shared_ptr<wchar_t[]> shared_pbuf;

    res = MultiByteToWideChar(CP_ACP, 0, psz, -1, buf, sizeof(buf)/sizeof(wchar_t));

    if (0 == res && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
        res = MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);

        shared_pbuf = boost::shared_ptr<wchar_t[]>(new wchar_t[res]);

        pbuf = shared_pbuf.get();

        res = MultiByteToWideChar(CP_ACP, 0, psz, -1, pbuf, res);
    }
    else if (0 == res)
    {
        pbuf = L"error";
    }

    return std::wstring(pbuf);
}

std::string get_string_from_wcs(const wchar_t* pcs)
{
    int res;
    char buf[0x400];
    char* pbuf = buf;
    boost::shared_ptr<char[]> shared_pbuf;

    res = WideCharToMultiByte(CP_ACP, 0, pcs, -1, buf, sizeof(buf), NULL, NULL);

    if (0 == res && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
    {
        res = WideCharToMultiByte(CP_ACP, 0, pcs, -1, NULL, 0, NULL, NULL);

        shared_pbuf = boost::shared_ptr<char[]>(new char[res]);

        pbuf = shared_pbuf.get();

        res = WideCharToMultiByte(CP_ACP, 0, pcs, -1, pbuf, res, NULL, NULL);
    }
    else if (0 == res)
    {
        pbuf = "error";
    }

    return std::string(pbuf);
}

3

Источник

user2245230 31 мар '14 в 15:54

#include <boost/locale.hpp>
namespace lcv = boost::locale::conv;

inline std::wstring fromUTF8(const std::string& s)
{ return lcv::utf_to_utf<wchar_t>(s); }

inline std::string toUTF8(const std::wstring& ws)
{ return lcv::utf_to_utf<char>(ws); }

2

Источник

user7231824 30 ноя '16 в 16:01

На случай, если кому-то еще будет интересно: мне нужен класс, который может использоваться взаимозаменяемо, где бы string или же wstring ожидалось. Следующий класс convertible_stringна основе решения dk123 можно инициализировать с помощью string, char const*, wstring или же wchar_t const* и может быть назначен или неявно преобразован в string или же wstring (так можно передать в функции, которые принимают либо).

class convertible_string
{
public:
    // default ctor
    convertible_string()
    {}

    /* conversion ctors */
    convertible_string(std::string const& value) : value_(value)
    {}
    convertible_string(char const* val_array) : value_(val_array)
    {}
    convertible_string(std::wstring const& wvalue) : value_(ws2s(wvalue))
    {}
    convertible_string(wchar_t const* wval_array) : value_(ws2s(std::wstring(wval_array)))
    {}

    /* assignment operators */
    convertible_string& operator=(std::string const& value)
    {
        value_ = value;
        return *this;
    }
    convertible_string& operator=(std::wstring const& wvalue)
    {
        value_ = ws2s(wvalue);
        return *this;
    }

    /* implicit conversion operators */
    operator std::string() const { return value_; }
    operator std::wstring() const { return s2ws(value_); }
private:
    std::string value_;
};

1

Источник

user1349673 31 авг '15 в 17:53

      std::string
convert_str(const std::wstring &s) {
  //not determinate how many bytes to place all wide characters.
  std::string res(2 * s.size(), '\0');
  while(1) {
    size_t num_used_char = std::wcstombs(res.data(), s.data(), res.size());
    if (num_used_char == (size_t) -1) {
      //do your error handling.
    } 
    else if (num_used_char < res.size()) {
      res.resize(num_used_char);
      break;
    }
    res.resize(2 * res.size());
  }
  return res;
}

0

Источник

user10302409 30 май '23 в 15:03

Я использую ниже, чтобы преобразовать wstring в строку.

std::string strTo;
char *szTo = new char[someParam.length() + 1];
szTo[someParam.size()] = '\0';
WideCharToMultiByte(CP_ACP, 0, someParam.c_str(), -1, szTo, (int)someParam.length(), NULL, NULL);
strTo = szTo;
delete szTo;

-1

Источник

user2588499 03 янв '18 в 17:03

// Embarcadero C++ Builder 

// convertion string to wstring
string str1 = "hello";
String str2 = str1;         // typedef UnicodeString String;   -> str2 contains now u"hello";

// convertion wstring to string
String str2 = u"hello";
string str1 = UTF8string(str2).c_str();   // -> str1 contains now "hello"

-3

Источник

user4239340 11 ноя '14 в 11:27

Другие вопросы по тегам c++ unicode stl wstring

user178761 26 янв '11 в 14:06 2011-01-26 14:06 · Accepted Answer · 2011-01-26 14:06

Вот разработанное решение, основанное на других предложениях:

#include <string>
#include <iostream>
#include <clocale>
#include <locale>
#include <vector>

int main() {
  std::setlocale(LC_ALL, "");
  const std::wstring ws = L"ħëłlö";
  const std::locale locale("");
  typedef std::codecvt<wchar_t, char, std::mbstate_t> converter_type;
  const converter_type& converter = std::use_facet<converter_type>(locale);
  std::vector<char> to(ws.length() * converter.max_length());
  std::mbstate_t state;
  const wchar_t* from_next;
  char* to_next;
  const converter_type::result result = converter.out(state, ws.data(), ws.data() + ws.length(), from_next, &to[0], &to[0] + to.size(), to_next);
  if (result == converter_type::ok or result == converter_type::noconv) {
    const std::string s(&to[0], to_next);
    std::cout <<"std::string =     "<<s<<std::endl;
  }
}

Обычно это работает для Linux, но создает проблемы в Windows.