C++字符串转换总结

以下C++字符串转换均在unicode编码下进行

---

string转wstring

当在 Unicode 下将 C++ 的 std::string 转换为 std::wstring 时，通常需要考虑字符串编码的问题。假设输入的 std::string 是 UTF-8 编码的，你可以使用以下代码来实现一个函数来进行转换：

#include 
#include 
#include 
#include 

std::wstring utf8ToWstring(const std::string &utf8Str) {
    std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
    return converter.from_bytes(utf8Str);
}

int main() {
    std::string utf8String = u8"你好，世界！";
    std::wstring wideString = utf8ToWstring(utf8String);

    std::wcout << wideString << std::endl;

    return 0;
}

这个示例代码中，utf8ToWstring 函数接受一个 UTF-8 编码的 std::string，并返回一个 std::wstring。它使用了 std::wstring_convert 类和 std::codecvt_utf8 转换器来进行转换。

注意，上述代码需要包含 、、 和 头文件，并且需要使用 C++11 或更高版本的标准。此外，确保你的编译器和环境支持 Unicode 转换操作。

在编译时可能需要加入编译选项 -std=c++11 或更高版本来启用 C++11 特性。如果你使用的是早期的编译器或环境，可能需要采取不同的方法来进行转换。

wstring转string

在 Unicode 下将 C++ 的 std::wstring 转换为 std::string 时，同样需要考虑字符串编码的问题。假设输入的 std::wstring 是宽字符编码（通常是 UTF-16 或 UTF-32 编码），你可以使用以下代码来实现一个函数来进行转换：

#include 
#include 
#include 
#include 

std::string wstringToUtf8(const std::wstring &wideStr) {
    std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
    return converter.to_bytes(wideStr);
}

int main() {
    std::wstring wideString = L"你好，世界！";
    std::string utf8String = wstringToUtf8(wideString);

    std::cout << utf8String << std::endl;

    return 0;
}

这个示例代码中，wstringToUtf8 函数接受一个宽字符编码的 std::wstring，并返回一个 UTF-8 编码的 std::string。它同样使用了 std::wstring_convert 类和 std::codecvt_utf8 转换器来进行转换。

与之前的示例类似，记得包含 、、 和 头文件，并确保你的编译器和环境支持 Unicode 转换操作。

同样需要在编译时加入 -std=c++11 或更高版本的编译选项来启用 C++11 特性。如果你使用的是早期的编译器或环境，可能需要使用不同的方法来进行转换。

MFC CString转wstring

当在 Unicode 下使用 C++ MFC 库进行字符串转换时，可以使用以下函数封装来实现从 CString 到 std::wstring 的转换：

#include  // 包含 MFC 头文件
#include 

std::wstring CStringToWString(const CString& cstr) {
    CT2CW pszUnicode(cstr); // 将 CString 转换为 const wchar_t*
    std::wstring wstr(pszUnicode); // 构造 std::wstring 对象
    return wstr;
}

这里的 CT2CW 宏将 CString 转换为 const wchar_t*。然后，我们使用 std::wstring 构造函数来创建一个 std::wstring 对象，将 Unicode 字符串从 MFC 格式转换为 C++ 标准库格式。

使用这个函数，可以将 CString 对象转换为 std::wstring 对象，如下所示：

CString cstr = _T("Hello, 你好");
std::wstring wstr = CStringToWString(cstr);

记得在使用前包含必要的头文件，确保正确编译和链接 MFC 库。请注意，这个函数假设的项目是基于 MFC 库编写的，并且使用 Unicode 字符集。

如果需要更复杂的字符串操作，可能需要在封装函数中添加更多的逻辑以处理不同的情况。此外，确保的开发环境配置正确，以便支持 Unicode 字符串处理。

MFC CString转string

在 Unicode 下使用 C++ MFC 进行字符串转换时，将 CString 转换为 std::string 需要一些额外的步骤，因为 CString 使用的是宽字符编码（UTF-16），而 std::string 使用的是窄字符编码（通常是 UTF-8）。

以下是一个封装函数，用于将 CString 转换为 std::string：

#include  // 包含 MFC 头文件
#include 
#include 
#include 

std::string CStringToUTF8(const CString& cstr) {
    int length = cstr.GetLength();
    if (length == 0) {
        return std::string();
    }

    CT2CA pszConvertedAnsiString(cstr); // 将 CString 转换为 const char*
    std::string utf8str(pszConvertedAnsiString); // 使用默认编码将窄字符转换为 UTF-8

    return utf8str;
}

这个函数使用了 MFC 提供的宏 CT2CA 来将 CString 转换为 const char*。然后，我们将窄字符编码的字符串转换为 UTF-8 编码的 std::string，使用了 C++11 引入的 std::wstring_convert 类。

使用这个函数，可以将 CString 对象转换为 UTF-8 编码的 std::string，如下所示：

CString cstr = _T("Hello, 你好");
std::string utf8str = CStringToUTF8(cstr);

确保在使用前包含必要的头文件，配置正确的开发环境以支持 Unicode 字符串处理，并在项目中使用正确的字符集。

请注意，这个函数仅处理基本的宽字符到窄字符的转换。对于更复杂的字符串操作，可能需要处理更多的情况，例如考虑多字节字符等。

MFC const char*转CString

在 Unicode 下，将 const char* 转换为 CString 需要一些步骤。下面是一个封装函数的示例，用于将 const char* 转换为 CString：

#include  // 包含 MFC 头文件

CString CharPtrToCString(const char* charPtr) {
    if (charPtr == nullptr) {
        return _T("");
    }

    USES_CONVERSION;
    LPCWSTR wideStr = A2CW(charPtr); // 将 const char* 转换为 LPCWSTR

    CString cstr(wideStr); // 构造 CString 对象
    return cstr;
}

在上面的函数中，我们使用了 MFC 提供的 USES_CONVERSION 宏，这将自动创建一个临时的宽字符缓冲区，从 const char* 转换为 LPCWSTR（宽字符字符串）。

使用这个函数，可以将 const char* 对象转换为 CString，如下所示：

const char* charPtr = "Hello, 你好";
CString cstr = CharPtrToCString(charPtr);

请确保在使用前包含必要的头文件，配置正确的开发环境以支持 Unicode 字符串处理，并在项目中使用正确的字符集。

这个函数只处理基本的转换，如果需要更复杂的操作（例如处理多字节字符等），可能需要进行更多的处理。

MFC CString转const char*

在 Unicode 下，将 CString 转换为 const char* 需要一些额外的步骤，因为 CString 使用的是宽字符编码（UTF-16），而 const char* 使用的是窄字符编码（通常是 UTF-8）。以下是一个封装函数的示例，用于将 CString 转换为 const char*：

#include  // 包含 MFC 头文件

const char* CStringToCharPtr(const CString& cstr) {
    if (cstr.IsEmpty()) {
        return "";
    }

    USES_CONVERSION;
    LPCSTR charPtr = W2CA(cstr); // 将 CString 转换为 LPCSTR

    return charPtr;
}

在上面的函数中，我们使用了 MFC 提供的 USES_CONVERSION 宏，这将自动创建一个临时的窄字符缓冲区，从 CString 转换为 LPCSTR（窄字符字符串）。

使用这个函数，可以将 CString 对象转换为 const char*，如下所示：

CString cstr = _T("Hello, 你好");
const char* charPtr = CStringToCharPtr(cstr);

请确保在使用前包含必要的头文件，配置正确的开发环境以支持 Unicode 字符串处理，并在项目中使用正确的字符集。

请注意，这个函数只处理基本的转换，如果需要更复杂的操作（例如处理多字节字符等），可能需要进行更多的处理。

char、wchar_t数组转string

在 Unicode 下，将 char 数组（UTF-8 编码）转换为 C++ 标准库的 std::string 是相对直接的操作。可以使用 std::string 的构造函数来实现这个转换。以下是一个示例函数，用于将 char 数组转换为 std::string：

#include 

std::string CharArrayToString(const char* charArray) {
    if (charArray == nullptr) {
        return std::string(); // 返回空字符串
    }

    return std::string(charArray);
}

使用这个函数，可以将 char 数组转换为 std::string，如下所示：

const char* charArray = "Hello, 你好";
std::string str = CharArrayToString(charArray);

请注意，这个函数假设输入的 char 数组是以 null 结尾的 C 字符串（C-style string）。

另外，如果在使用 wchar_t 编码的宽字符数组（UTF-16 编码），可以使用类似的方法将其转换为 std::wstring，只需将 std::string 替换为 std::wstring。

#include 

std::wstring WcharArrayToWString(const wchar_t* wcharArray) {
    if (wcharArray == nullptr) {
        return std::wstring(); // 返回空字符串
    }

    return std::wstring(wcharArray);
}

使用这个函数，可以将 wchar_t 数组转换为 std::wstring，如下所示：

const wchar_t* wcharArray = L"Hello, 你好";
std::wstring wstr = WcharArrayToWString(wcharArray);

请确保在使用前包含必要的头文件，并根据需要适当地配置开发环境。

TCHAR数组转到CString

 TCHAR m_buf[100] = _T("Hello");
 CString str;
 str.Format(L"%s",m_buf);

CString转为TCHAR数组

CString str = L"sssssss";
TCHAR m_buf[20];
_tcscpy(m_buf, str);