c++ 字符编码转换

BVR

已于 2024-01-10 00:19:27 修改

阅读量484

点赞数 10

分类专栏： C/C++ 文章标签： c++

于 2024-01-10 00:16:26 首次发布

本文链接：https://blog.csdn.net/baseterminal/article/details/135491955

版权

C/C++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章介绍了在C++中处理字符串（string和wstring）转换的方法，包括使用标准库函数、COMutility头文件以及locale和codecvt进行宽窄字符转换，特别关注了中文字符的处理和VS环境中的UTF-8编码问题。

摘要由CSDN通过智能技术生成

方法一

#include <Windows.h>
#include <string>

//将string转换成wstring  
wstring string2wstring(string str)  
{  
    wstring result;  
    //获取缓冲区大小，并申请空间，缓冲区大小按字符计算  
    int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, 0);  
    TCHAR* buffer = new TCHAR[len + 1];  
    //多字节编码转换成宽字节编码  
    MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, len);  
    buffer[len] = '\0';             //添加字符串结尾  
    //删除缓冲区并返回值  
    result.append(buffer);  
    delete[] buffer;  
    return result;  
}  
 
//将wstring转换成string  
string wstring2string(wstring wstr)  
{  
    string result;  
    //获取缓冲区大小，并申请空间，缓冲区大小事按字节计算的  
    int len = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), NULL, 0, NULL, NULL);  
    char* buffer = new char[len + 1];  
    //宽字节编码转换成多字节编码  
    WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), buffer, len, NULL, NULL);  
    buffer[len] = '\0';  
    //删除缓冲区并返回值  
    result.append(buffer);  
    delete[] buffer;  
    return result;  
}

方法二

#include <comutil.h>  
#include <string>
#pragma comment(lib, "comsuppw.lib")
 
string ws2s(const wstring& ws)
{
    _bstr_t t = ws.c_str();  
    char* pchar = (char*)t;  
    string result = pchar;  
    return result;  
}
 
wstring s2ws(const string& s)
{
    _bstr_t t = s.c_str();  
    wchar_t* pwchar = (wchar_t*)t;  
    wstring result = pwchar;  
    return result; 
}

方法三

#include <locale>
#include <codecvt>
#include <string>

//convert string to wstring
inline std::wstring to_wide_string(const std::string& input)
{
  std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
  return converter.from_bytes(input);
}

//convert wstring to string 
inline std::string to_byte_string(const std::wstring& input)
{
  std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
  return converter.to_bytes(input);
}

方法三在vs环境中运行时，输入中带有中文时converter.from_bytes会抛出异常，可作如下修改

//convert string to wstring
inline std::wstring to_wide_string(const std::string& input)
{
  std::wstring_convert<std::codecvt<wchar_t, char, std::mbstate_t>> decode(new std::codecvt<wchar_t, char, std::mbstate_t>("CHS"));
  return decode.from_bytes(input);
}

//convert wstring to string 
inline std::string to_byte_string(const std::wstring& input)
{
  std::wstring_convert<std::codecvt<wchar_t, char, std::mbstate_t>> decode(new std::codecvt<wchar_t, char, std::mbstate_t>("CHS"));
  return decode.to_bytes(input);
}

或者将程序的执行字符集设置为UTF-8 ¹ ²

方法四

//转换宽窄字符串时可以成功，并且支持中文转换
const std::wstring s2ws_local(const std::string& s)
{
  std::locale old_loc = std::locale::global(std::locale(""));
  const char* src_str = s.c_str();
  const size_t buffer_size = s.size() + 1;
  wchar_t* dst_wstr = new wchar_t[buffer_size];
  wmemset(dst_wstr, 0, buffer_size);
  mbstowcs(dst_wstr, src_str, buffer_size);
  std::wstring result = dst_wstr;
  delete[]dst_wstr;
  std::locale::global(old_loc);
  return result;
}

const std::string ws2s_local(const std::wstring& ws)
{
  std::locale old_loc = std::locale::global(std::locale(""));
  const wchar_t* src_wstr = ws.c_str();
  size_t buffer_size = ws.size() * 4 + 1;
  char* dst_str = new char[buffer_size];
  memset(dst_str, 0, buffer_size);
  wcstombs(dst_str, src_wstr, buffer_size);
  std::string result = dst_str;
  delete[]dst_str;
  std::locale::global(old_loc);
  return result;
}

全部代码如下

#include <Windows.h>
#include <string>
#include <iostream>
#include <locale>
#include <codecvt>
#include <vector>

#include <comutil.h>  
#pragma comment(lib, "comsuppw.lib")

using namespace std;


//转换宽窄字符串时可以成功，并且支持中文转换
const std::wstring s2ws_local(const std::string& s)
{
  std::locale old_loc = std::locale::global(std::locale(""));
  const char* src_str = s.c_str();
  const size_t buffer_size = s.size() + 1;
  wchar_t* dst_wstr = new wchar_t[buffer_size];
  wmemset(dst_wstr, 0, buffer_size);
  mbstowcs(dst_wstr, src_str, buffer_size);
  std::wstring result = dst_wstr;
  delete[]dst_wstr;
  std::locale::global(old_loc);
  return result;
}

const std::string ws2s_local(const std::wstring& ws)
{
  std::locale old_loc = std::locale::global(std::locale(""));
  const wchar_t* src_wstr = ws.c_str();
  size_t buffer_size = ws.size() * 4 + 1;
  char* dst_str = new char[buffer_size];
  memset(dst_str, 0, buffer_size);
  wcstombs(dst_str, src_wstr, buffer_size);
  std::string result = dst_str;
  delete[]dst_str;
  std::locale::global(old_loc);
  return result;
}


string ws2s(const wstring& ws)
{
  _bstr_t t = ws.c_str();
  char* pchar = (char*)t;
  string result = pchar;
  return result;
}

wstring s2ws(const string& s)
{
  _bstr_t t = s.c_str();
  wchar_t* pwchar = (wchar_t*)t;
  wstring result = pwchar;
  return result;
}

//convert string to wstring
inline std::wstring to_wide_string(const std::string& input)
{
  std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
  return converter.from_bytes(input);

  //std::wstring_convert<std::codecvt<wchar_t, char, std::mbstate_t>> decode(new std::codecvt<wchar_t, char, std::mbstate_t>("CHS"));
  //return decode.from_bytes(input);
}

//convert wstring to string 
inline std::string to_byte_string(const std::wstring& input)
{

  std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
  return converter.to_bytes(input);

  //std::wstring_convert<std::codecvt<wchar_t, char, std::mbstate_t>> decode(new std::codecvt<wchar_t, char, std::mbstate_t>("CHS"));
  //return decode.to_bytes(input);
}


//将string转换成wstring  
wstring string2wstring(string str)
{
  wstring result;
  //获取缓冲区大小，并申请空间，缓冲区大小按字符计算  
  int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, 0);
  TCHAR* buffer = new TCHAR[len + 1];
  //多字节编码转换成宽字节编码  
  MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, len);
  buffer[len] = '\0';             //添加字符串结尾  
  //删除缓冲区并返回值  
  result.append(buffer);
  delete[] buffer;
  return result;
}

//将wstring转换成string  
string wstring2string(wstring wstr)
{
  string result;
  //获取缓冲区大小，并申请空间，缓冲区大小事按字节计算的  
  int len = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), NULL, 0, NULL, NULL);
  char* buffer = new char[len + 1];
  //宽字节编码转换成多字节编码  
  WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), buffer, len, NULL, NULL);
  buffer[len] = '\0';
  //删除缓冲区并返回值  
  result.append(buffer);
  delete[] buffer;
  return result;
}

int main()
{
  wstring wide_text = string2wstring("hello, 你好");
  string narrow_text = wstring2string(wide_text);
  std::cout << narrow_text << std::endl;

  wide_text = s2ws("hello, 你好");
  narrow_text = ws2s(wide_text);
  std::cout << narrow_text << std::endl;

  wide_text = to_wide_string("hello, 你好");
  narrow_text = to_byte_string(wide_text);
  std::cout << narrow_text << std::endl;

  wide_text = s2ws_local("hello, 你好");
  narrow_text = ws2s_local(wide_text);
  std::cout << narrow_text << std::endl;

  return 0;
}