wchar_t 、UTF-8、UTF-16的转换方法

已于 2022-02-28 13:55:04 修改
阅读量3.6k 收藏 8
点赞数
分类专栏： 编码与加密 文章标签： gnu windows c++
于 2022-02-25 15:26:58 首次发布
原文链接：https://blog.csdn.net/gwj239/article/details/9120489
版权

Unicode 有两套编码集，UCS-2 和 UCS-4。Windows 的内部其实是用的 UCS-2 标准，并用 UTF-16 来实现。而非 Windows 系统大多采用了 UTF-8 实现。

      大家都知道在windows上wchar_t是2个字节表示，而在Linux上wchar_t是4个字节表示的。这样写跨平台的程序时，就会不统一。

下面是我用到的几个函数，wchar_t与UTF-8编码之间的转换和UTF-16和wchar_t之间的转换。

#ifdef WINDOWS
#include <windows.h>
#include <stdio.h>
#include <ctype.h>
#else
#include <iconv.h>
#include <wctype.h>
#include <wchar.h>
#include <errno.h>
#endif

//wchar_t转成UTF-8
int FW2UTF8Convert(const wchar_t* a_szSrc, int a_nSrcSize, char* a_szDest, int a_nDestSize)
{
#ifdef WINDOWS
    return WideCharToMultiByte(CP_UTF8, 0, a_szSrc, -1, a_szDest, a_nDestSize, NULL, NULL);
#else
    size_t result;
    iconv_t env;
    env = iconv_open("UTF-8", "WCHAR_T");
    if (env == (iconv_t)-1)
    {
        printf("iconv_open WCHAR_T->UTF8 error%s %d/n", strerror(errno), errno);
        return -1;
    }
    result = iconv(env, (char**)&a_szSrc, (size_t*)&a_nSrcSize, (char**)&a_szDest, (size_t*)&a_nDestSize);
    if (result == (size_t)-1)
    {
        printf("iconv WCHAR_T->UTF8 error %d/n", errno);
        return -1;
    }
    iconv_close(env);
    return (int)result;
#endif
}

//UTF-8转成wchar_t
int FUTF82WConvert(const char* a_szSrc, wchar_t* a_szDest, int a_nDestSize)
{
#ifdef WINDOWS
    return MultiByteToWideChar(CP_UTF8, 0, a_szSrc, -1, a_szDest, a_nDestSize);
#else
    size_t result;
    iconv_t env;
    int size = strlen(a_szSrc) + 1;
    env = iconv_open("WCHAR_T", "UTF-8");
    if (env == (iconv_t)-1)
    {
        printf("iconv_open UTF8->WCHAR_T error %d/n", errno);
        return -1;
    }
    result = iconv(env, (char**)&a_szSrc, (size_t*)&size, (char**)&a_szDest, (size_t*)&a_nDestSize);
    if (result == (size_t)-1)
    {
        printf("iconv UTF8->WCHAR_T error %d/n", errno);
        return -1;
    }
    iconv_close(env);
    return (int)result;
#endif
}

//wchar_t转成utf16
int FW2UConvert(const wchar_t* a_szSrc, int  a_nSize, char* a_szDest, int a_nDestSize)
{
#ifdef WINDOWS
    memcpy_s((wchar_t*)a_szDest, a_nDestSize, a_szSrc, a_nSize);
    return a_nSize;
#else
    size_t result;
    iconv_t env;
    env = iconv_open("UCS-2-INTERNAL", "UCS-4-INTERNAL");
    if (env == (iconv_t)-1)
    {
        printf("iconv_open WCHAR_T->UTF16 error%s %d/n", strerror(errno), errno);
        return -1;
    }
    result = iconv(env, (char**)&a_szSrc, (size_t*)&a_nSize, (char**)&a_szDest, (size_t*)&a_nDestSize);
    if (result == (size_t)-1)
    {
        printf("iconv WCHAR_T->UTF16 error %s %d/n", strerror(errno), errno);
        return -1;
    }
    iconv_close(env);
    return (int)result;
#endif
}

//utf16转成wchar_t
int FU2WConvert(const  char* a_szSrc, int a_nSize, wchar_t* a_szDest, int a_nDestSize)
{
#ifdef WINDOWS
    memcpy_s(a_szDest, a_nDestSize, (const wchar_t*)a_szSrc, a_nSize);
    return a_nSize;
#else
    size_t result;
    iconv_t env;
    env = iconv_open("UCS-4-INTERNAL", "UCS-2-INTERNAL");
    if (env == (iconv_t)-1)
    {
        printf("iconv_open error %d/n", errno);
        return -1;
    }
    result = iconv(env, (char**)&a_szSrc, (size_t*)&a_nSize, (char**)&a_szDest, (size_t*)&a_nDestSize);
    if (result == (size_t)-1)
    {
        printf("UTF16 -> WCHAR_T conv error %d/n", errno);
        return -1;
    }
    iconv_close(env);
    return (int)result;
#endif
}

ps：在Linux上我用的是iconv库.其中wchar_t一般以UCS-4标准。

     UCS-4-INTERNAL ，UCS-2-INTERNAL  会根据本机的存储方式(大端、小端)进行处理。

     还有UCS-2LE和UCS-2BE 分别代表小端和大端模式。

字符串乱码往往是由于编码不一致或编码没有对应的字符所致，为了能够正常显示字符串，经常会有需要编码转换的需要，为了方便使用这里整理成一个head-only文件，这里提供了char、wchar_t、utf-8之间的转换，在实际的项目中建议使用wchar_t/utf-8，强烈建议使用utf-8。

#pragma once
#include <Windows.h>
#include <string>
#include <vector>
#include <assert.h>
 
/*!
 * 编码转换命名空间
 * 
 */
namespace ZEncode
{
    /*!
     * 窄字节转宽字节
     * 
     * \param str 窄字节
     * \param uCodePage 窄字节编码
     * \return 宽字节
     */
    static std::wstring A2W(const std::string &str, UINT uCodePage)
    {
        int nLength = ::MultiByteToWideChar(uCodePage, 0, str.c_str(), -1, NULL, 0);
        if (0 == nLength)
        {
            throw std::exception("A2W Error");
        }
        std::wstring strW(nLength, L'\0');
        int nResult = ::MultiByteToWideChar(uCodePage, 0, str.c_str(), -1, &strW[0], nLength);
        if (nResult != nLength)
        {
            throw std::exception("A2W Error");
        }
        strW.resize(nLength - 1);
        return strW;
    }
 
    /*!
     * 宽字节转窄字节
     * 
     * \param str 宽字节
     * \param uCodePage 窄字节编码
     * \return 窄字节
     */
    static std::string W2A(const std::wstring &str, UINT uCodePage)
    {
        int nLength = ::WideCharToMultiByte(uCodePage, 0, str.c_str(), -1, NULL, 0, NULL, NULL);
        if (0 == nLength)
        {
            throw std::exception("W2A Error");
        }
        std::string strA(nLength, '\0');
        int nResult = ::WideCharToMultiByte(uCodePage, 0, str.c_str(), -1, &strA[0], nLength, NULL, NULL);
        if (nResult != nLength)
        {
            throw std::exception("W2A Error");
        }
        strA.resize(nLength - 1);
        return strA;
    }
 
    /*!
     * 窄字节转窄字节
     * 
     * \param str 窄字节
     * \param uCodePageFrom 源始字节编码
     * \param uCodePageTo 目标字节编码
     * \return 窄字节
     */
    static std::string A2A(const std::string &str, UINT uCodePageFrom, UINT uCodePageTo)
    {
        return W2A(A2W(str, uCodePageFrom), uCodePageTo);
    }
 
    /*!
     * 检查缓冲区数据是否是UTF-8
     * 
     * \param pBuffer 缓冲区
     * \param size 大小
     * \return 如果是返回true，否则返回false。
     * 
     * \note 返回结果并不一定完全正确，仅作为一个参考用途。
     */
    static bool IsUTF8(const void* pBuffer, size_t size)
    {
        //参考 http://blog.csdn.net/bladeandmaster88/article/details/54767487
        bool bIsUTF8 = true;
        unsigned char* start = (unsigned char*)pBuffer;
        unsigned char* end = (unsigned char*)pBuffer + size;
 
        while (start < end)
        {
            if (*start < 0x80) // (10000000): 值小于0x80的为ASCII字符     
            {
                start++;
            }
            else if (*start < (0xC0)) // (11000000): 值介于0x80与0xC0之间的为无效UTF-8字符     
            {
                bIsUTF8 = false;
                break;
            }
            else if (*start < (0xE0)) // (11100000): 此范围内为2字节UTF-8字符     
            {
                if (start >= end - 1)
                    break;
 
                if ((start[1] & (0xC0)) != 0x80)
                {
                    bIsUTF8 = false;
                    break;
                }
                start += 2;
            }
            else if (*start < (0xF0)) // (11110000): 此范围内为3字节UTF-8字符
            {
                if (start >= end - 2)
                    break;
 
                if ((start[1] & (0xC0)) != 0x80 || (start[2] & (0xC0)) != 0x80)
                {
                    bIsUTF8 = false;
                    break;
                }
                start += 3;
            }
            else
            {
                bIsUTF8 = false;
                break;
            }
        }
 
        return bIsUTF8;
    }
 
    /*!
    * 检查字符串是不是UTF-8编码
    *
    * \param str 缓冲区
    * \return 如果是返回true，否则返回false。
    * 
    * \note 返回结果并不一定完全正确，仅作为一个参考用途。
    */
    static bool IsUTF8(const std::string &str)
    {
        return IsUTF8(str.c_str(), str.size());
    }
}
 
//为了方便方便使用定义的宏
#define ANSI_TO_WCHAR(str)         (ZEncode::A2W(str, CP_ACP))
#define ANSI_TO_UTF8(str)          (ZEncode::A2A(str, CP_ACP, CP_UTF8))
 
#define UTF8_TO_ANSI(str)          (ZEncode::A2A(str, CP_UTF8, CP_ACP))
#define UTF8_TO_WCHAR(str)         (ZEncode::A2W(str, CP_UTF8))
 
#define WCHAR_TO_ANSI(str)         (ZEncode::W2A(str, CP_ACP))
#define WCHAR_TO_UTF8(str)         (ZEncode::W2A(str, CP_UTF8))


    TEST(ZEncode, ansi_to_wchar_to_ansi)
    {
        std::string strANSI("中华人民共和国");
        std::wstring strWChar = ANSI_TO_WCHAR(strANSI);
        EXPECT_STREQ(strWChar.c_str(), L"中华人民共和国");
        EXPECT_STREQ(WCHAR_TO_ANSI(strWChar).c_str(), "中华人民共和国");
    }
 
    TEST(ZEncode, ansi_to_utf8_to_wchar)
    {
        std::string strANSI("中华人民共和国");
        std::string strUTF8 = ANSI_TO_UTF8(strANSI);
        EXPECT_FALSE(ZEncode::IsUTF8(strANSI));
        EXPECT_TRUE(ZEncode::IsUTF8(strUTF8));
        EXPECT_STREQ(UTF8_TO_WCHAR(strUTF8).c_str(), L"中华人民共和国");
    }
 
    TEST(ZEncode, ansi_to_utf8_to_ansi)
    {
        std::string strANSI("中华人民共和国");
        std::string strUTF8 = ANSI_TO_UTF8(strANSI);
        EXPECT_FALSE(ZEncode::IsUTF8(strANSI));
        EXPECT_TRUE(ZEncode::IsUTF8(strUTF8));
        EXPECT_STREQ(UTF8_TO_ANSI(strUTF8).c_str(), strANSI.c_str());
    }
 
    TEST(ZEncode, wchar_to_utf8_to_wchar)
    {
        std::wstring strWChar(L"中华人民共和国");
        std::string strUTF8 = WCHAR_TO_UTF8(strWChar);
        EXPECT_TRUE(ZEncode::IsUTF8(strUTF8));
        EXPECT_STREQ(UTF8_TO_WCHAR(strUTF8).c_str(), strWChar.c_str());
    }

 其它：在C++11中，如果希望初始化的字符串编码为utf-8，只需要在字符前面新增u8即可，如下：

1

2

std::string s1 = "中华人民共和国";  //取决于文件编码

std::string s2 = u8"中华人民共和国";  //utf-8编码

dolphin98629
关注
专栏目录
编码问题：unicode与utf-8，wchar_t与char
成长
11-02 7509
unicode与utf-8 wchar_t
wchar_t*和string相互转换 unicode 转utf8
wqs880527的博客
05-15 1038
在window环境中，可以利用 MultiByteToWideChar(); WideCharToMultiByte(); 单字节字符串string转双字节字符串wchar_t* //不要忘记在使用完wchar_t*后delete[]释放内存 wchar_t *multiByteToWideChar(const string& pKey) { const char* pCStrKey = pKey.c_str(); //第一次调用返回转换后的字符串长度，用于确认为wchar_t*开辟
关于C++11中的wchar_t,char16_t,char32_t以及延申出来的编码知识
最新发布
abgjkk的博客
10-05 1274
在 C++ 中，wchar_tchar16_t和char32_t是用于表示不同宽度字符类型的类型，它们主要用于处理不同的字符编码集，特别是在需要支持国际化（多语言）环境时。这些类型用于表示比标准的char类型更宽的字符，从而支持更多字符集，例如 Unicode 字符。
wchar_t 、UTF-8、UTF-16的转换方法 - luketty的专栏 - 博客频道 - CSDN.NET
weixin_34082789的博客
04-08 335
wchar_t 、UTF-8、UTF-16的转换方法 - luketty的专栏 - 博客频道 - CSDN.NETwchar_t 、UTF-8、UTF-16的转换方法
char(utf8)转为wchar_t 中文乱码
不知东方之既白
06-12 713
MultiByteToWideChar函数可以将UTF-8编码的char类型字符串转换为wchar_t类型字符串。参数wchar_t类型，因此需要进行此类转换。经过多次尝试，以下方法可行。
char wchar uft8 字符转换
huoshui0112的博客
05-22 629
1 char*转换为wchar_t [cpp]view plaincopy //char*towchar_twchar_twfilename[256]={0};charfilename[]={"c://init.properties"};ulBytes=MultiByteToWideChar(CP_ACP,0,filename,-1,NULL
char, wchar_t,UTF8,UNICODE,GBK转换
normallife的专栏
01-19 8046
<br />1 char* 转换为wchar_t <br /><br />view plaincopy to clipboardprint?<br />//char* to wchar_t   <br />wchar_t wfilename[256] ={0};   <br />char filename[] = {"c://init.properties"};   <br />ulBytes = MultiByteToWideChar(CP_ACP,0,filename,-1,NULL,0);   <br
2UTF-1.22.tar.gz_utf-8 c++
09-24
4. 处理宽字符：C++中的宽字符类型（如wchar_t），宽字符字符串（如std::wstring），以及如何在宽字符和窄字符（如UTF-8）之间进行操作。 5. Unicode字符集：理解Unicode字符集的结构，包括不同类型的Unicode编码...
utf-8 utf-16对比windows系统下wchar_t和char中文字符的二进制对比
ustb_atrx的博客
12-25 2924
对比的源程序(cpp) : // 针对汉字的utf-8 和utf-16对比 #include "stdafx.h" #include "windows.h" #include #include #include using namespace std; int _tmain(int argc, _TCHAR* argv[]) {     char *pc = "中
c++ UTF-8 UTF-16转换
05-01
在编程领域，尤其是在涉及到字符编码的时候，理解和操作UTF-8和UTF-16之间的转换是一项基本技能。UTF-8和UTF-16是两种广泛使用的Unicode编码格式，它们各自有其特性和应用场景。本文将深入探讨如何利用C++来实现这两...
wchar_t 转换UTF16编码
crazy Crypto
04-27 3563
wchar_t在Windows下的是utf16编码，Linux下面则是utf32编码，有些时候这些不同会带来代码移植问题。 下列转换宏提供了从wchar_t 到UTF16编码的转换     #ifdef WIN32 #define USES_WCSUTF16_CON
java wchar_将UTF-8文本转换为wchar_t
weixin_33773996的博客
02-16 270
我知道这个问题在这里被问了很多次，我确实读了一些答案，但是有一些建议的解决方案，我试图找出最好的解决方案 .我正在编写一个基本上接收以UTF-8编码的XML文本的C99应用程序 .它的一部分工作是复制和操作该字符串(查找substr，cat it，ex ..)因为我现在不想使用外部非标准库，我试图使用wchar_t来实现它 .目前，即时通讯使用mbstowcs将其转换为wchar_t以便于操作，对...
Linux下转换字符集(UTF8转换)
热门推荐
wuxinyanzi的专栏
10-16 3万+
今天在Linux 下使用 Iconv 命令转换一个UTF8文件时，总是转换不成功。提示： iconv: 未知 0 处的非法输入序列 后来使用 man iconv 查看，还是没发现异常，因为命令格式都是正确的。后来找了许多资料才知道原因，如下： a. 在做编码转换的时候，如果你的源格式设定为 GB2312 的话，而且在转换成 UTF-8 的时候，发现程序会报“illegal inp
C语言实现Unicode编码和UTF-8互转
ByteZenith的博客
08-09 2358
在C语言中，我们需要进行Unicode编码和UTF-8编码的转换，本篇文章将介绍如何实现这两个编码之间的相互转换。UTF-8编码使用1~4个字节来表示不同的字符，每一个字节都以“0”开头，其中第一个字节还包含了该字符所需的字节数信息。UTF-8编码使用1~4个字节来表示不同的字符，每一个字节都以“0”开头，其中第一个字节还包含了该字符所需的字节数信息。最后，我们将解析出的Unicode编码放入wchar_t类型的数组中，并且在数组末尾添加一个L’\0’字符，以表示数组的结束。
linux 宽字符串,linux C 宽字符wchar_t处理
weixin_39713841的博客
04-30 829
如果字符都是ascii字符，声明成char类型就可以处理了，更节省空间。当遇到中文等非ascii字符时，如果要逐字符处理，这时就需要用到wchar_t了。一、编码讲宽字符前，需要了解字符编码。GBK只适合中文，UTF-8适合所有字符。GBK是双字节编码，详细介绍：http://www.qqxiuzi.cn/zh/hanzi-gbk-bianma.phpUTF-8编码是Unicode的传输形式，也就...
多字节与UTF-8、Unicode之间的转换
happyrabbit456的专栏
10-29 726
转载：http://www.cppblog.com/deane/articles/120243.html   // 多字节编码转为UTF8编码   bool MBToUTF8(vectorchar>& pu8, const char* pmb, int32 mLen)   {    // convert an MBCS string to widechar
编码格式：GBK（多字节），Unicode编码，UTF-8,UTF-16,char与wchar_t（tchar）的关系
冷崖的博客
03-09 1139
多字节编码 基本可以算是GBK编码，而在C/C++，经常使用的char和string，都算是多字节编码（GBK），char类型占用一个字节，8 bit，最多可以表示256个字符。 Unicode编码 Unicode的学名 是"Universal Multiple-Octet Coded Character Set"，简称为UCS。UCS可以看作是"Unicode Character Set"的缩写...
c++怎么把代码页为 UTF-8的字符数组转换为wchar_t的字符数组
05-12
可以使用Windows API中的MultiByteToWideChar函数来实现将UTF-8编码的字符数组转换为wchar_t的字符数组。 示例代码如下： ```c++ #include <Windows.h> #include <iostream> int main() { const char* utf8Str = u8"你好，世界！"; int utf8Len = strlen(utf8Str); int wstrLen = MultiByteToWideChar(CP_UTF8, 0, utf8Str, utf8Len, nullptr, 0); wchar_t* wstr = new wchar_t[wstrLen + 1]; MultiByteToWideChar(CP_UTF8, 0, utf8Str, utf8Len, wstr, wstrLen); wstr[wstrLen] = L'\0'; std::wcout << wstr << std::endl; delete[] wstr; return 0; } ``` 解释： - `MultiByteToWideChar`函数的第一个参数`CP_UTF8`表示输入的字符数组的编码格式为UTF-8，第二个参数`0`表示不进行特殊处理，第三个参数`utf8Str`表示输入的UTF-8编码的字符数组，第四个参数`utf8Len`表示输入字符数组的长度，第五个参数`nullptr`表示不需要输出转换后的结果，第六个参数`0`表示获取输出缓冲区的长度。 - 第一次调用`MultiByteToWideChar`函数获取输出缓冲区的长度。 - 根据获取到的输出缓冲区长度创建wchar_t类型的输出缓冲区。 - 第二次调用`MultiByteToWideChar`函数将UTF-8编码的字符数组转换为wchar_t类型的字符数组。 - 最后在wchar_t类型的字符数组末尾加上`\0`作为字符串结束符。 - 使用`std::wcout`输出wchar_t类型的字符数组。注意要使用`wcout`而不是`cout`。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值