Std::string and std::wstring convert

std::string text("text");
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
std::wstring wtext = converter.from_bytes(text);

std::wstring to_wstring(const std::string& text)
{
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
    return converter.from_bytes(text);
}
 
std::string to_string(const std::wstring& text)
{
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
    return converter.to_bytes(text);
}

std::string ws2s(const std::wstring& wstr, const std::locale& loc)
{
    if (wstr.empty())
        return std::string();
 
    typedef std::wstring::traits_type::state_type state_type;
    typedef std::codecvt<wchar_t, char, state_type> convert;
    
    const convert& cvt = std::use_facet<convert>(loc);
    std::string str(cvt.max_length()*wstr.size(), '\0');
    state_type state = state_type();
 
    const wchar_t* from_beg = &wstr[0];
    const wchar_t* from_end = from_beg + wstr.size();
    const wchar_t* from_nxt;
    char* to_beg = &str[0];
    char* to_end = to_beg + str.size();
    char* to_nxt;
    
    std::string::size_type sz = 0;
    std::codecvt_base::result r;
    do
    {
        r = cvt.out(state, from_beg, from_end, from_nxt,
                           to_beg,   to_end,   to_nxt);
        switch (r)
        {
        case std::codecvt_base::error:
            throw std::runtime_error("error converting wstring to string");
 
        case std::codecvt_base::partial:
            sz += to_nxt - to_beg;
            str.resize(2*str.size());
            to_beg = &str[sz];
            to_end = &str[0] + str.size();
            break;
 
        case std::codecvt_base::noconv:
            str.resize(sz + (from_end-from_beg)*sizeof(wchar_t));
            std::memcpy(&str[sz], from_beg,(from_end-from_beg)*sizeof(wchar_t));
            r = std::codecvt_base::ok;
            break;
 
        case std::codecvt_base::ok:
            sz += to_nxt - to_beg;
            str.resize(sz);
            break;
        }
    } while (r != std::codecvt_base::ok);
 
    return str;
}

std::wstring _stdcall AnsiStringToWide(std::string const &Str, UINT CodePage = CP_ACP)
{
    DWORD const BuffSize = MultiByteToWideChar(CodePage, 0, Str.c_str(), -1, NULL, 0);
    if (!BuffSize) return NULL;
    std::vector<wchar_t> Buffer;
    Buffer.resize(BuffSize);
    if (!MultiByteToWideChar(CodePage, 0, Str.c_str(), -1, &Buffer[0], BuffSize)) return NULL;
    return (&Buffer[0]);
}
 
std::string _stdcall WideStringToAnsi(std::wstring const &Str, UINT CodePage = CP_ACP)
{
    DWORD const BuffSize = WideCharToMultiByte(CodePage, 0, Str.c_str(), -1, NULL, 0, NULL, NULL);
    if (!BuffSize) return NULL;
    std::vector<char> Buffer;
    Buffer.resize(BuffSize);
    if (!WideCharToMultiByte(CodePage, 0, Str.c_str(), -1, &Buffer[0], BuffSize, NULL, NULL)) return NULL;
    return (&Buffer[0]);
}

std::wstring to_wstring(char *str)
{
    int max_len = strlen(str)+1;
    std::wstring wstr; wstr.resize(max_len);    
    MultiByteToWideChar(CP_ACP, 0, str, -1, (LPWSTR)wstr.c_str(), max_len);
    return wstr;
}
 
std::string to_string(wchar_t *wstr)
{
    int max_len = lstrlen(wstr);
    std::string str; str.resize(max_len);
    WideCharToMultiByte(CP_ACP, 0, wstr, -1, (LPSTR)str.c_str(), max_len, NULL, NULL);
    return str;
}

char *str = "некоторая строка";
wchar_t *wstr = (wchar_t*)to_wstring(str).c_str(); // тут создаётся временный объект wstring и возвращается указатель на его данные, после этой строки объект уничтожится вместе с данными

std::auto_ptr<WCHAR> to_wchar_str(char *str)
{
    int max_len = strlen(str)+1;
    WCHAR *wstr = new WCHAR[max_len];
    MultiByteToWideChar(CP_ACP, 0, str, -1, wstr, max_len);
    return std::auto_ptr<WCHAR>(wstr);
}
 
std::auto_ptr<char> to_char_str(wchar_t *wstr)
{
    int max_len = lstrlen(wstr)+1;
    char *str = new char[max_len];  
    WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, max_len, NULL, NULL);
    return std::auto_ptr<char>(str);
}

namespace convert
{
    // конвертирует std::string -> [ANSI] -> std::wstring
    int StrToWStr(std::wstring &dest, const std::string &source)
    {
        int source_len = source.length();
 
        dest.resize(source_len + 1);
        int dest_len = MultiByteToWideChar(CP_ACP, 0, source.c_str(), -1, (WCHAR*)dest.c_str(), source_len + 1);
 
        return dest_len;
    }
 
    // конвертирует std::wstring -> [ANSI] -> std::string
    int WStrToStr(std::string &dest, const std::wstring &source)
    {
        int source_len = source.length() + 1;
 
        dest.resize(source_len * 2 + 1);
        int dest_len = WideCharToMultiByte(CP_ACP, 0, source.c_str(), -1, (LPSTR)dest.c_str(), source_len * 2 + 1, NULL, NULL);
        dest.resize(dest_len); dest.shrink_to_fit(); // укорачивание памяти под dest
 
        return dest_len;
    }
 
    // конвертирует std::string -> [CodePage] -> std::string
    int StrTo(std::string& dest, const std::string& source, UINT ResultCodePage = CP_ACP, DWORD dwFlags = 0) // параметры см. в WideCharToMultiByte
    {
        int source_len = source.length();
 
        WCHAR *wstr = new WCHAR[source_len + 1];
        MultiByteToWideChar(CP_ACP, 0, source.c_str(), -1, wstr, source_len + 1);
 
        dest.resize(source_len * 2 + 1);
        int dest_len = WideCharToMultiByte(ResultCodePage, dwFlags, wstr, -1, (LPSTR)dest.c_str(), source_len * 2 + 1, NULL, NULL);
        dest.resize(dest_len); dest.shrink_to_fit(); // укорачивание памяти под dest
 
        delete[] wstr;
 
        return dest_len;
    }
 
    // конвертирует std::wstring -> [CodePage] -> std::string
    int WStrTo(std::string& dest, const std::wstring& source, UINT ResultCodePage = CP_ACP, DWORD dwFlags = 0) // параметры см. в WideCharToMultiByte
    {
        int source_len = source.length();
 
        dest.resize(source_len * 2 + 1);
        int dest_len = WideCharToMultiByte(ResultCodePage, dwFlags, source.c_str(), -1, (LPSTR)dest.c_str(), source_len * 2 + 1, NULL, NULL);
        dest.resize(dest_len); dest.shrink_to_fit(); // укорачивание памяти под dest
 
        return dest_len;
    }
}

WCHAR *wstr = new WCHAR[source_len + 1];

std::vector<WCHAR> wstr(source_len + 1);

std::unique_ptr<WCHAR[]> wstr(new WCHAR[source_len + 1]);

auto wstr = std::make_unique<WCHAR[]>(source_len + 1);