Linux 平台和 Windows平台下 Unicode与UTF-8互转

Windows:

unsigned char * make_utf8_string(const wchar_t *unicode)
{
    int size = , index = , out_index = ;
    unsigned char *out;
    unsigned short c;

    /* first calculate the size of the target string */
    c = unicode[index++];
    while(c)
    {
        if(c < 0x0080)
        {
            size += ;
        }
        else if(c < 0x0800)
        {
            size += ;
        }
        else
        {
            size += ;
        }

        c = unicode[index++];
    }

    out = (unsigned char*)malloc(size + );
    if (out == NULL)
        return NULL;

    index = ;

    c = unicode[index++];
    while(c)
    {
        if(c < 0x080)
        {
            out[out_index++] = (unsigned char)c;
        }
        else if(c < 0x800)
        {
            out[out_index++] = 0xc0 | (c >> );
            out[out_index++] = 0x80 | (c & 0x3f);
        }
        else
        {
            out[out_index++] = 0xe0 | (c >> );
            out[out_index++] = 0x80 | ((c >> ) & 0x3f);
            out[out_index++] = 0x80 | (c & 0x3f);
        }
        c = unicode[index++];
    }

    out[out_index] = 0x00;

    return out;
}

wchar_t * make_unicode_string(const unsigned char *utf8)
{
    int size = , index = , out_index = ;
    wchar_t *out;
    unsigned char c;

    /* first calculate the size of the target string */
    c = utf8[index++];
    while(c)
    {
        if((c & 0x80) == )
        {
            index += ;
        }
        else if((c & 0xe0) == 0xe0)
        {
            index += ;
        }
        else
        {
            index += ;
        }

        size += ;
        c = utf8[index++];
    }

    out = (wchar_t*)malloc((size + ) * sizeof(wchar_t));
    if (out == NULL)
        return NULL;

    index = ;

    c = utf8[index++];
    while(c)
    {
        if((c & 0x80) == )
        {
            out[out_index++] = c;
        }
        else if((c & 0xe0) == 0xe0)
        {
            out[out_index] = (c & 0x1F) << ;
            c = utf8[index++];
            out[out_index] |= (c & 0x3F) << ;
            c = utf8[index++];
            out[out_index++] |= (c & 0x3F);
        }
        else
        {
            out[out_index] = (c & 0x3F) << ;
            c = utf8[index++];
            out[out_index++] |= (c & 0x3F);
        }

        c = utf8[index++];
    }

    out[out_index] = ;

    return out;
}

int StrUtil::utf8_encode(const char *from, char **to)
{
    wchar_t *unicode;
    int wchars, err;

    wchars = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, from,
        strlen(from), NULL, );

    if (wchars == )
    {
        fprintf(stderr, "Unicode translation error %d\n", GetLastError());
        return -;
    }

    unicode = (wchar_t*)calloc(wchars + , sizeof(unsigned short));
    if(unicode == NULL)
    {
        fprintf(stderr, "Out of memory processing string to UTF8\n");
        return -;
    }

    err = ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, from,
        strlen(from), unicode, wchars);
    if(err != wchars)
    {
        free(unicode);
        fprintf(stderr, "Unicode encode error %d\n", GetLastError());
        return -;
    }

    /* On NT-based windows systems, we could use WideCharToMultiByte(), but
    * MS doesn't actually have a consistent API across win32.
    */
    *to = (char *)make_utf8_string(unicode);

    free(unicode);
    return ;
}

int StrUtil::utf8_decode(const char *from, char **to)
{
    wchar_t *unicode;
    int chars, err;

    /* On NT-based windows systems, we could use MultiByteToWideChar(CP_UTF8), but
    * MS doesn't actually have a consistent API across win32.
    */
    unicode = make_unicode_string((unsigned char*)from);
    if(unicode == NULL)
    {
        fprintf(stderr, "Out of memory processing string from UTF8 to UNICODE16\n");
        return -;
    }

    chars = ::WideCharToMultiByte(GetConsoleCP(), WC_COMPOSITECHECK, unicode,
        -, NULL, , NULL, NULL);

    if(chars == )
    {
        fprintf(stderr, "Unicode translation error %d\n", GetLastError());
        free(unicode);
        return -;
    }

    *to = (char *)calloc(chars + , sizeof(unsigned char));
    if(*to == NULL)
    {
        fprintf(stderr, "Out of memory processing string to local charset\n");
        free(unicode);
        return -;
    }

    err = ::WideCharToMultiByte(GetConsoleCP(), WC_COMPOSITECHECK, unicode,
        -, *to, chars, NULL, NULL);
    if(err != chars)
    {
        fprintf(stderr, "Unicode decode error %d\n", GetLastError());
        free(unicode);
        free(*to);
        *to = NULL;
        return -;
    }

    free(unicode);
    return ;
}

Linux 平台：

unsigned char * make_utf8_string(const wchar_t *unicode)
{
    int size = , index = , out_index = ;
    unsigned char *out;
    unsigned short c;

    /* first calculate the size of the target string */
    c = unicode[index++];
    while(c)
    {
        if(c < 0x0080)
        {
            size += ;
        }
        else if(c < 0x0800)
        {
            size += ;
        }
        else
        {
            size += ;
        }

        c = unicode[index++];
    }

    out = (unsigned char*)malloc(size + );
    if (out == NULL)
        return NULL;

    index = ;

    c = unicode[index++];
    while(c)
    {
        if(c < 0x080)
        {
            out[out_index++] = (unsigned char)c;
        }
        else if(c < 0x800)
        {
            out[out_index++] = 0xc0 | (c >> );
            out[out_index++] = 0x80 | (c & 0x3f);
        }
        else
        {
            out[out_index++] = 0xe0 | (c >> );
            out[out_index++] = 0x80 | ((c >> ) & 0x3f);
            out[out_index++] = 0x80 | (c & 0x3f);
        }
        c = unicode[index++];
    }

    out[out_index] = 0x00;

    return out;
}

wchar_t * make_unicode_string(const unsigned char *utf8)
{
    int size = , index = , out_index = ;
    wchar_t *out;
    unsigned char c;

    /* first calculate the size of the target string */
    c = utf8[index++];
    while(c)
    {
        if((c & 0x80) == )
        {
            index += ;
        }
        else if((c & 0xe0) == 0xe0)
        {
            index += ;
        }
        else
        {
            index += ;
        }

        size += ;
        c = utf8[index++];
    }

    out = (wchar_t*)malloc((size + ) * sizeof(wchar_t));
    if (out == NULL)
        return NULL;

    index = ;

    c = utf8[index++];
    while(c)
    {
        if((c & 0x80) == )
        {
            out[out_index++] = c;
        }
        else if((c & 0xe0) == 0xe0)
        {
            out[out_index] = (c & 0x1F) << ;
            c = utf8[index++];
            out[out_index] |= (c & 0x3F) << ;
            c = utf8[index++];
            out[out_index++] |= (c & 0x3F);
        }
        else
        {
            out[out_index] = (c & 0x3F) << ;
            c = utf8[index++];
            out[out_index++] |= (c & 0x3F);
        }

        c = utf8[index++];
    }

    out[out_index] = ;

    return out;
}

int utf8_encode(const char *from, char **to)
{
    wchar_t *unicode = NULL;
    int wchars, err;

    setlocale(LC_ALL,"");
    wchars = mbstowcs(unicode, from, )+;

    unicode = new wchar_t[wchars];

    err = mbstowcs(unicode, from, wchars);
    if(err < )
    {
        delete unicode;
        fprintf(stderr, "Unicode encode error \n");
        return -;
    }

    setlocale(LC_ALL,"C");

    *to = (char *)make_utf8_string(unicode);

    delete unicode;

    return ;
}

int utf8_decode(const char *from, char **to)
{
    wchar_t *unicode = NULL;
    int chars, err;    

   // setlocale(LC_ALL,"zh_CN.GB18030");

    unicode = make_unicode_string((unsigned char*)from);

    setlocale(LC_ALL,"");
    chars = wcstombs(*to,unicode, )* + ;

    *to = new char[chars];
    memset(*to, , chars);

    //setlocale(LC_ALL,"");
    err = wcstombs(*to, unicode, chars);
    setlocale(LC_ALL,"C");

    delete unicode;
    if(err < )
    {
        fprintf(stderr, "Unicode decode error \n");
        delete *to;
        *to = NULL;
        return -;
    }

    return ;
}