Как преобразовать wstring в const char * в C ++ 17? [Дубликат]

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

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

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

В случае, если кому-то интересен: мне нужен класс, который мог бы использоваться взаимозаменяемо везде, где ожидались 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_;
};

#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); }

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

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

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

EDIT

Однако в случае преобразования в строку 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);
}

EDIT использовать «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);
}

Я использую ниже, чтобы преобразовать 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;

Вы можете просто использовать узкий метод ctype facet:

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

inline std::string narrow(std::wstring const& text)
{
    std::locale const loc("");
    wchar_t const* from = text.c_str();
    std::size_t const len = text.size();
    std::vector<char> buffer(len + 1);
    std::use_facet<std::ctype<wchar_t> >(loc).narrow(from, from + len, '_', &buffer[0]);
    return std::string(&buffer[0], &buffer[len]);
}

Решение от: 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;

] Остерегайтесь того, что здесь есть no преобразование набора символов. Это просто означает, что каждый итерированный 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 юникода в основном одинаковы, поэтому, если это кодовая страница, в которой вы используете большинство этих символов, должна быть усечена до правильных значений. (Я полностью ожидал, что и работаю, я знаю, что наш код на работе опирается на это для é, который я скоро исправлю)

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