Як конвертувати CString та std :: string std :: wstring один до одного?

CStringє досить зручним, хоча std::stringє більш сумісним із контейнером STL. Я використовую hash_map. Однак hash_mapне підтримує CStrings як клавіші, тому я хочу перетворити CStringa на std::string.

Написання CStringхеш-функції займає багато часу.

CString -----> std::string

Як я можу це зробити?

std::string -----> CString:

inline CString toCString(std::string const& str)
{
    return CString(str.c_str()); 
}

Я правий?

РЕДАГУВАТИ:

Ось ще запитання:

Як я можу перетворити з wstringна CStringі навпаки?

// wstring -> CString
std::wstring src;
CString result(src.c_str());

// CString -> wstring
CString src;
std::wstring des(src.GetString());

Чи є з цим якісь проблеми?

Крім того, як я можу конвертувати з std::wstringв std::stringі навпаки?

Відповідно до CodeGuru :

CStringдо std::string:

CString cs("Hello");
std::string s((LPCTSTR)cs);

АЛЕ: std::string не завжди можна побудувати з LPCTSTR. тобто код буде невдалим для збірок UNICODE.

Як std::stringможе побудувати тільки з LPSTR/ LPCSTR, програміст, який використовує VC ++ 7.x або краще, може використовувати класи перетворення, такі як CT2CAпосередник.

CString cs ("Hello");
// Convert a TCHAR string to a LPCSTR
CT2CA pszConvertedAnsiString (cs);
// construct a std::string using the LPCSTR input
std::string strStd (pszConvertedAnsiString);

std::stringдоCString : (З поширених запитань про CString у Visual Studio ... )

std::string s("Hello");
CString cs(s.c_str());

CStringTможе будувати як з символьних, так і з широкосимвольних рядків. тобто він може конвертувати з char*(тобто LPSTR) або з wchar_t*( LPWSTR).

Іншими словами, спеціальна спеціалізація (з CStringT), тобтоCStringA , wchar_t-specilization CStringWі TCHAR-specialization CStringможуть бути виготовлені з будь-якого charабо широкого характеру,нуль припинено (нуль-завершення тут дуже важливо)рядкові джерела.
Althoug IIspectable вносить зміни до частини "припинення нуля" у коментарях :

Припинення NUL не потрібно .
CStringTмає конструктори перетворення, які приймають явний аргумент довжини. Це також означає, що ви можете будувати CStringTоб'єкти з std::stringоб'єктів із вбудованими NULсимволами.

Вирішіть це, використовуючи std::basic_string<TCHAR>замість, std::stringі це повинно працювати нормально незалежно від налаштування вашого персонажа.

Більш ефективно перетворити CStringна std::stringвикористання перетворення, де вказана довжина.

CString someStr("Hello how are you");
std::string std(somStr, someStr.GetLength());

У щільному циклі це значно покращує продуктивність.

Якщо ви хочете щось більше на С ++, наприклад, я цим користуюся. Хоча це залежить від Boost, це лише для винятків. Ви можете легко видалити тих, хто залишає це залежати лише від STL та WideCharToMultiByte()виклику Win32 API.

#include <string>
#include <vector>
#include <cassert>
#include <exception>

#include <boost/system/system_error.hpp>
#include <boost/integer_traits.hpp>

/**
 * Convert a Windows wide string to a UTF-8 (multi-byte) string.
 */
std::string WideStringToUtf8String(const std::wstring& wide)
{
    if (wide.size() > boost::integer_traits<int>::const_max)
        throw std::length_error(
            "Wide string cannot be more than INT_MAX characters long.");
    if (wide.size() == 0)
        return "";

    // Calculate necessary buffer size
    int len = ::WideCharToMultiByte(
        CP_UTF8, 0, wide.c_str(), static_cast<int>(wide.size()), 
        NULL, 0, NULL, NULL);

    // Perform actual conversion
    if (len > 0)
    {
        std::vector<char> buffer(len);
        len = ::WideCharToMultiByte(
            CP_UTF8, 0, wide.c_str(), static_cast<int>(wide.size()),
            &buffer[0], static_cast<int>(buffer.size()), NULL, NULL);
        if (len > 0)
        {
            assert(len == static_cast<int>(buffer.size()));
            return std::string(&buffer[0], buffer.size());
        }
    }

    throw boost::system::system_error(
        ::GetLastError(), boost::system::system_category);
}

(З VS2012 ... і принаймні до VS2017 v15.8.1)

Оскільки це проект MFC, а CString - це клас MFC, MS надає Технічну примітку TN059: Використання макросів перетворення MFC MBCS / Unicode та загальних макросів перетворення:

A2CW      (LPCSTR)  -> (LPCWSTR)  
A2W       (LPCSTR)  -> (LPWSTR)  
W2CA      (LPCWSTR) -> (LPCSTR)  
W2A       (LPCWSTR) -> (LPSTR)  

Використання:

void Example() // ** UNICODE case **
{
    USES_CONVERSION; // (1)

    // CString to std::string / std::wstring
    CString strMfc{ "Test" }; // strMfc = L"Test"
    std::string strStd = W2A(strMfc); // ** Conversion Macro: strStd = "Test" **
    std::wstring wstrStd = strMfc.GetString(); // wsrStd = L"Test"

    // std::string to CString / std::wstring
    strStd = "Test 2";
    strMfc = strStd.c_str(); // strMfc = L"Test 2"
    wstrStd = A2W(strStd.c_str()); // ** Conversion Macro: wstrStd = L"Test 2" **

    // std::wstring to CString / std::string 
    wstrStd = L"Test 3";
    strMfc = wstrStd.c_str(); // strMfc = L"Test 3"
    strStd = W2A(wstrStd.c_str()); // ** Conversion Macro: strStd = "Test 3" **
}

-

Виноски:

(1) Щоб макроси перетворення мали простір для зберігання тимчасової довжини, необхідно оголосити локальну змінну, яка називається, _convertщо робить це у кожній функції, яка використовує макроси перетворення. Це робиться за допомогою USES_CONVERSIONмакросу. У коді VFC2017 MFC (atlconv.h) це виглядає так:

#ifndef _DEBUG
    #define USES_CONVERSION int _convert; (_convert); UINT _acp = ATL::_AtlGetConversionACP() /*CP_THREAD_ACP*/; (_acp); LPCWSTR _lpw; (_lpw); LPCSTR _lpa; (_lpa)
#else
    #define USES_CONVERSION int _convert = 0; (_convert); UINT _acp = ATL::_AtlGetConversionACP() /*CP_THREAD_ACP*/; (_acp); LPCWSTR _lpw = NULL; (_lpw); LPCSTR _lpa = NULL; (_lpa)
#endif

Чи є якісь проблеми?

Є кілька питань:

• CStringє спеціалізацією на шаблонах CStringT . Залежно від базового типу, що описує тип символу, існує дві конкретні спеціалізації: CStringA(використання char) таCStringW (використання wchar_t).
• У той час як wchar_tв Windows повсюдно використовується для зберігання кодованих кодових одиниць UTF-16, використовуючиchar неоднозначне. Останній зазвичай зберігає кодовані символи ANSI, але також може зберігати ASCII, UTF-8 або навіть двійкові дані.
• Ми не знаємо кодування символів (або навіть типу символів) CString(яке керується за допомогою _UNICODEсимволу препроцесора), що робить питання неоднозначним. Ми також не знаємо бажаного кодування символів std::string.
• Перетворення між Unicode та ANSI за своєю суттю є втратним: кодування ANSI може представляти лише підмножину набору символів Unicode.

Для вирішення цих питань я збираюся припустити, що wchar_tбудуть зберігатися кодовані кодові коди UTF-16 таchar матимуть послідовності октетів UTF-8. Це єдиний розумний вибір, який ви можете зробити, щоб забезпечити збереження однакової інформації в рядках джерела та призначення, не обмежуючи рішення лише підмножиною вихідних або цільових доменів.

Наступні реалізації перетворюють між CStringA/ CStringWта std::wstring/ std::stringвідображення з UTF-8 на UTF-16 і навпаки:

#include <string>
#include <atlconv.h>

std::string to_utf8(CStringW const& src_utf16)
{
    return { CW2A(src_utf16.GetString(), CP_UTF8).m_psz };
}

std::wstring to_utf16(CStringA const& src_utf8)
{
    return { CA2W(src_utf8.GetString(), CP_UTF8).m_psz };
}

Решта дві функції будують рядкові об'єкти C ++ із рядків MFC, залишаючи кодування незмінним. Зауважте, що хоча попередні функції не можуть впоратися із вбудованими символами NUL, ці функції не захищені від цього.

#include <string>
#include <atlconv.h>

std::string to_std_string(CStringA const& src)
{
    return { src.GetString(), src.GetString() + src.GetLength() };
}

std::wstring to_std_wstring(CStringW const& src)
{
    return { src.GetString(), src.GetString() + src.GetLength() };
}

Це чудово працює:

//Convert CString to std::string
inline std::string to_string(const CString& cst)
{
    return CT2A(cst.GetString());
}

Це продовження відповіді Сала, де він / вона надав рішення:

CString someStr("Hello how are you");
std::string std(somStr, someStr.GetLength());

Це корисно також при перетворенні нетипової C-String в std :: string

Випадок використання для мене був попередньо виділений масив char (наприклад, C-String), але він не припинявся NUL. (тобто дайджест SHA). Вищезазначений синтаксис дозволяє мені вказати довжину дайджесту SHA масиву char, щоб std :: string не мусив шукати кінцевий символ NUL, який може там бути, а може і не бути.

Як от:

unsigned char hashResult[SHA_DIGEST_LENGTH];    
auto value = std::string(reinterpret_cast<char*>hashResult, SHA_DIGEST_LENGTH);

з цього допису (Дякую, Марк Ренсом )

Перетворити CString на рядок (VC6)

Я перевірив це, і воно чудово працює.

std::string Utils::CString2String(const CString& cString) 
{
    std::string strStd;

    for (int i = 0;  i < cString.GetLength();  ++i)
    {
        if (cString[i] <= 0x7f)
            strStd.append(1, static_cast<char>(cString[i]));
        else
            strStd.append(1, '?');
    }

    return strStd;
}

Ви можете використовувати CT2CA

CString datasetPath;
CT2CA st(datasetPath);
string dataset(st);

Працює для мене:

std::wstring CStringToWString(const CString& s)
{
    std::string s2;
    s2 = std::string((LPCTSTR)s);
    return std::wstring(s2.begin(),s2.end());
}

CString WStringToCString(std::wstring s)
{
    std::string s2;
    s2 = std::string(s.begin(),s.end());
    return s2.c_str();
}

Усі інші відповіді не зовсім стосувались того, що я шукав, а саме перетворення CStringна льоту, на відміну від збереження результату у змінній.

Рішення подібне до наведеного вище, але нам потрібен ще один крок для створення екземпляра безіменного об’єкта. Я ілюструю на прикладі. Ось моя функція, яка потрібна, std::stringале у мене є CString.

void CStringsPlayDlg::writeLog(const std::string &text)
{
    std::string filename = "c:\\test\\test.txt";

    std::ofstream log_file(filename.c_str(), std::ios_base::out | std::ios_base::app);

    log_file << text << std::endl;
}

Як назвати це, коли у вас є CString?

std::string firstName = "First";
CString lastName = _T("Last");

writeLog( firstName + ", " + std::string( CT2A( lastName ) ) );     

Зверніть увагу, що останній рядок не є прямим набором типів, але ми створюємо безіменний std::stringоб'єкт і постачаємо його CStringчерез його конструктор.

конвертувати CString to std::string. Ви можете використовувати цей формат.

std::string sText(CW2A(CSText.GetString(), CP_UTF8 ));

Якщо ви хочете легко перетворити між іншими типами рядків, можливо, _bstr_tклас був би доречнішим? Він підтримує converstion між char, wchar_tі BSTR.

Один цікавий підхід полягає в гіпс , CStringщоб CStringAусередині stringконструктора. На відміну від std::string s((LPCTSTR)cs);цього буде працювати, навіть якщо _UNICODEвизначено. Однак, якщо це так, це буде виконувати перетворення з Unicode в ANSI, тому небезпечно для вищих значень Unicode, що перевищують набір символів ASCII. Таке перетворення підлягає _CSTRING_DISABLE_NARROW_WIDE_CONVERSIONвизначенню препроцесора. https://msdn.microsoft.com/en-us/library/5bzxfsea.aspx

        CString s1("SomeString");
        string s2((CStringA)s1);

Ви можете CStringвільно транслювати, const char*а потім призначити його std::stringтаким чином:

CString cstring("MyCString");
std::string str = (const char*)cstring;