字符编码转换 各种函数 UTF格式转换、

最新推荐文章于 2020-05-06 18:10:38 发布
最新推荐文章于 2020-05-06 18:10:38 发布
阅读量1.3k 收藏
点赞数
分类专栏： C语言 文章标签： null c encoding table 2010 url
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeff_2009/article/details/6095576
版权

/*
 * codeconv.c
 *
 * Heidun IDS developer team
 *  Created on: Jun 11, 2009
 *      Author: Xiaodong Zhong
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "our_design_config_init.h"
#include "code_table.h"


typedef unsigned char   uchar;
typedef unsigned short  ushort;
static u_int8_t EBCDIC_translate_ASCII [ 256 ] = {
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
    0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
    0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
    0x2E, 0x2E, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
    0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x2E, 0x3F,
    0x20, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x2E, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
    0x26, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
    0x2D, 0x2F, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x7C, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
    0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
    0x2E, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
    0x69, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
    0x72, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
    0x7A, 0x2E, 0x2E, 0x2E, 0x5B, 0x2E, 0x2E,
    0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x2E, 0x2E, 0x2E, 0x5D, 0x2E, 0x2E,
    0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
    0x49, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51,
    0x52, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x5C, 0x2E, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
    0x5A, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
    0x39, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E
};

void EBCDIC_to_ASCII(u_int8_t *buf, u_int32_t bytes)
{
 u_int32_t i;
 u_int8_t *bufptr;

 bufptr = buf;

 for (i = 0; i < bytes; i++, bufptr++) {
  *bufptr = EBCDIC_translate_ASCII[*bufptr];
 }
}

u_int8_t EBCDIC_to_ASCII1(u_int8_t c)
{
 return EBCDIC_translate_ASCII[c];
}

/**
* 0     ----Little Endian UTF-16 串(低字节在前)
* != 0  ----Big    Endian UTF-16 串(高字节在前)
**/
static int isLittleEndian =  0;

/**
*  功  能: 设置 UTF-16 编码方式
*  输  入:
*        0     ----Little Endian UTF-16 串(低字节在前)
*        1     ----Big    Endian UTF-16 串(高字节在前)
*  输  出:
*  返  回:
**/
int SetEndian()
{
    uchar   *p = NULL;
    ushort  tst = 0x1234;

    /* 获取CPU字节码顺序 */
    p = (uchar *)&tst;

    if     (*p == 0x12) isLittleEndian = 1;
    else if(*p == 0x34) isLittleEndian = 0;
    else
    {
        LogMessage( "Unknown CPU Bytes Order!/n");
        return -1;
    }

    return 0;
}

/**
*  功  能: 将 UTF-16 编码转成 UTF-8 编码
*  输  入: inb      ----utf-16字串
*          inlenb   ----utf-16字串长度(字节数)
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----utf-8字串
*          outlen   ----utf-8字串长度
*  返  回: >= 0     ----转换后utf-8字串长度
*          -1       ----转换出错
**/
int UTF16ToUTF8(uchar *out, int *outlen, const uchar *inb, int *inlenb)
{
    uchar* outstart = out;
    const uchar* processed = inb;
    uchar* outend = out + *outlen;
    ushort* in = (unsigned short*) inb;
    ushort* inend;
    unsigned int c, d, inlen;
    unsigned char *tmp;
    int bits;

    if((*inlenb % 2) == 1) (*inlenb)--;
    inlen = *inlenb / 2;
    inend = in + inlen;
    while((in < inend) && (out - outstart + 5 < *outlen))
    {
        if(isLittleEndian)
        {
            c= *in++;
        }
        else
        {
            tmp = (unsigned char *) in;
            c   = *tmp++;
            c   = c | (((unsigned int)*tmp) << 8);
            in++;
        }
        if((c & 0xFC00) == 0xD800)
        {
            if(in >= inend) break;
            if(isLittleEndian) { d = *in++; }
            else
            {
                tmp = (unsigned char *) in;
                d   = *tmp++;
                d   = d | (((unsigned int)*tmp) << 8);
                in++;
            }
            if((d & 0xFC00) == 0xDC00)
            {
                c &= 0x03FF;
                c <<= 10;
                c |= d & 0x03FF;
                c += 0x10000;
            }
            else
            {
                *outlen = out - outstart;
                *inlenb = processed - inb;
                return -1;
            }
        }

        if(out >= outend)    break;
        if     (c <    0x80) { *out++ =  c;                        bits= -6; }
        else if(c <   0x800) { *out++ = ((c >>  6) & 0x1F) | 0xC0; bits=  0; }
        else if(c < 0x10000) { *out++ = ((c >> 12) & 0x0F) | 0xE0; bits=  6; }
        else                 { *out++ = ((c >> 18) & 0x07) | 0xF0; bits= 12; }

        for(; bits >= 0; bits-= 6)
        {
            if (out >= outend)
            break;
            *out++ = ((c >> bits) & 0x3F) | 0x80;
        }
        processed = (const unsigned char*) in;
    }

    *outlen = out - outstart;
    *inlenb = processed - inb;

    return(*outlen);
}

/**
*  功  能: 将 UTF-8 编码转成 UTF-16 编码
*  输  入: in       ----utf-8字串
*          inlen    ----utf-8字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: outb     ----utf-16字串
*          outlenb  ----utf-16字串长度(字节数)
*  返  回: >= 0     ----转换后utf-16字串长度(字节数)
*          -1       ----转换出错
**/
int UTF8ToUTF16(uchar *outb, int *outlen, const uchar *in, int *inlen)
{
    ushort *out = (unsigned short*) outb;
    const uchar* processed = in;
    const uchar *const instart = in;
    ushort *outstart= out, *outend;
    const uchar* inend;
    unsigned int c, d;
    int trailing;
    uchar *tmp;
    ushort tmp1, tmp2;

    if((out == NULL) || (outlen == NULL) || (inlen == NULL)) return -1;
    if(in == NULL)
    {
        *outlen = 0;
        *inlen = 0;
        return 0;
    }
    inend= in + *inlen;
    outend = out + (*outlen / 2);
    while(in < inend)
    {
        d= *in++;
        if     (d < 0x80) { c= d; trailing= 0; }
        else if(d < 0xC0)
        {
            *outlen = (out - outstart) * 2;
            *inlen = processed - instart;
            return -1;
        }
        else if(d < 0xE0)  { c= d & 0x1F; trailing= 1; }
        else if(d < 0xF0)  { c= d & 0x0F; trailing= 2; }
        else if(d < 0xF8)  { c= d & 0x07; trailing= 3; }
        else
        {
            *outlen = (out - outstart) * 2;
            *inlen = processed - instart;
            return -1;
        }

        if(inend - in < trailing)  break;

        for(; trailing; trailing--)
        {
            if((in >= inend) || (((d= *in++) & 0xC0) != 0x80))
            break;
            c <<= 6;
            c |= d & 0x3F;
        }

        if(c < 0x10000)
        {
            if(out >= outend) break;
            if(isLittleEndian) { *out++ = c; }
            else
            {
                tmp        = (unsigned char *) out;
                *tmp       = c ;
                *(tmp + 1) = c >> 8 ;
                out++;
            }
        }
        else if(c < 0x110000)
        {
            if(out+1 >= outend) break;
            c -= 0x10000;
            if(isLittleEndian)
            {
                *out++ = 0xD800 | (c >> 10);
                *out++ = 0xDC00 | (c & 0x03FF);
            }
            else
            {
                tmp1       = 0xD800 | (c >> 10);
                tmp        = (unsigned char *) out;
                *tmp       = (unsigned char) tmp1;
                *(tmp + 1) = tmp1 >> 8;
                out++;

                tmp2       = 0xDC00 | (c & 0x03FF);
                tmp        = (unsigned char *) out;
                *tmp       = (unsigned char) tmp2;
                *(tmp + 1) = tmp2 >> 8;
                out++;
            }
        }
        else break;

        processed = in;
    }

    *outlen = (out - outstart) * 2;
    *inlen = processed - instart;

    return(*outlen);
}

/**
*  功  能: 查找 GB2312 编码对应的 UTF-16 编码值(二分法查找)
*  输  入: gbkey    ----GB2312编码值
*  输  出:
*  返  回: >= 0     ----UTF-16编码值
*          -1       ----编码表无对应GB2312编码
*  引  用: 全局变量
*    _GB2UTFTable   ----GB2312->UNICODE对照表
**/
short UTF16Seek(ushort gbkey)
{
    int first = 0, mid = 0;
    int end = GBUTF_TABLE_SIZE - 1;

    while(first <= end)
    {
        mid = (first + end) >> 1;

        if (_GB2UTFTable[mid].gbcode == gbkey)
        {
            return _GB2UTFTable[mid].unicode;
        }

        if (_GB2UTFTable[mid].gbcode > gbkey)
        {
            end = mid - 1;
        }
        else
        {
            first = mid + 1;
        }
    }

    return -1;
}

/**
*  功  能: 查找 UTF-16 编码对应的 GB2312 编码值(二分法查找)
*  输  入: utfkey   ----UTF-16编码值
*  输  出:
*  返  回: >= 0     ----GB2312编码值
*          -1       ----编码表无对应UTF-16编码
*  引  用: 全局变量
*     _UTF2GBTable  ----UNICODE->GB2312对照表
**/
short GBSeek(ushort utfkey)
{
    int first = 0, mid = 0;
    int end = UTFGB_TABLE_SIZE - 1;

    while(first <= end)
    {
        mid = (first + end) >> 1;

        if (_UTF2GBTable[mid].unicode == utfkey)
        {
            return _UTF2GBTable[mid].gbcode;
        }

        if (_UTF2GBTable[mid].unicode > utfkey)
        {
            end = mid - 1;
        }
        else
        {
            first = mid + 1;
        }
    }

    return -1;
}

/**
*  功  能: 计算 UTF-16 编码字串的长度(双字节数)
*  输  入: in      ----UTF-16字串缓冲区
*  输  出:
*  返  回: >= 0    ----UTF-16编码长度(双字节数)
**/
long UTF16Len(const uchar *in)
{
    register  int i = 0;

    if(NULL == in) return 0;
    while(1)
    {
        if(0 == in[2*i] && 0 == in[2*i+1])
            break;
        i++;
    }

    return i;
}

/**
*  功  能: 将 UTF-16 编码转成 GB2312 编码
*  输  入: in       ----utf-16字串
*          inlen    ----utf-16字串长度(字节数)
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----GB2312字串
*  返  回: >=0      ----转换后GB2312字串长度(字节数)
*          -1       ----转换出错
**/
int UTF16ToGB(uchar *out, int outlen, uchar *in, int inlen)
{
    register int i = 0, k = 0;
    ushort  c1 = 0, c2 = 0;
    int     len = 0;

    if(NULL == in) { out[0] = '/0'; return 0; }

    len = (inlen < 0 ? 0 : inlen);
    if(len % 2 == 1) len --;
    i = 0;
    if(len >= 2)
    {
        /* UTF-16编码方式 */
        if(in[0] == 0xFF && in[1] == 0xFE)
        {
            i = 2;
        }
        if(in[0] == 0xFE && in[1] == 0xFF)
        {
            i = 2;
        }
    }

    for(i, k = 0; i < len; i += 2)
    {
        if(isLittleEndian)
        {
            c1 = (in[i] << 8) | (uchar)in[i+1];
        }
        else
        {
            c1 = (in[i+1] << 8) | (uchar)in[i];
        }
        c2 = GBSeek(c1);
        if(-1 == (short)c2)
        {
            LogMessage( "At [%d] [0x%4.4X] not found!/n", i, c1);
            return -1;
        }

        if(NULL == out)  return -1;
        if(0xFF00 & c2)
        {
            if(k >= outlen - 3) return -1;

            out[k++] = c2 >> 8;
            out[k++] = c2 & 0x00FF;
        }
        else
        {
            if(k >= outlen - 1) return -1;

            out[k++] = (uchar)c2;
        }
    }
    out[k] = 0;

    return k;
}

/**
*  功  能: 将 UTF-8 编码转成 GB2312 编码
*  输  入: in       ----utf-8字串
*          inlen    ----utf-8字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----GB2312字串
*  返  回: >=0      ----转换后GB2312字串长度(字节数)
*          -1       ----转换出错
**/
int UTF8ToGB(uchar *out, int outlen, uchar *in, int inlen)
{
    uchar *out1 = NULL;
    int len = 0, len1 = 0, len2 = 0;

    len = (inlen < 0 ? 0 : inlen);
    len1 = 2 * len;
    out1 = (uchar *)calloc(1, len1 + 2);
    if(NULL == out1)
    {
        LogMessage( "allot memory error!/n");
        return -1;
    }

    len1 = UTF8ToUTF16(out1, &len1, in, &len);
    if(len1 <= 0)
    {
        free(out1);
        return len1;
    }

    len2 = outlen;
    len2 = UTF16ToGB(out, len2, out1, len1);
    free(out1);

    return len2;
}

/**
*  功  能: 将 GB2312 编码转成 UTF-16 编码
*  输  入: in       ----GB2312字串
*          inlen    ----GB2312字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----utf-16字串
*  返  回: >=0      ----转换后utf-16字串长度(字节数)
*          -1       ----转换出错
**/
int GBToUTF16(uchar *out, int outlen, uchar *in, int inlen)
{
    register int i, k;
    ushort    c1, c2;
    int       len = 0;

    if(NULL == in)
    {
        out[0] = '/0';
        return 0;
    }

    len = (inlen < 0 ? 0 : inlen);

    for(i = 0, k = 0; i < len; i++)
    {
        c1 = (uchar)in[i];
        c2 = UTF16Seek(c1);          /* 查找单字节码 */
        if(-1 == (short)c2)
        {
            if(++i < len)
            {
                c1 = (c1 << 8) | (uchar)in[i];
                c2 = UTF16Seek(c1);  /* 查找双字节码 */
                if(-1 == (short)c2)
                {
                    LogMessage( "At [%d] [0x%4.4X] not found1!/n", i, c1);
                    return -1;
                }
            }
            else
            {
                LogMessage( "At [%d] [0x%4.4X] not found2!/n", i, c1);
                return -1;
            }
        }

        /* 超出输出缓冲区的大小 */
        if(k > outlen -3) return -1;

        if(isLittleEndian)
        {
            out[k++] = c2 >> 8;
            out[k++] = c2 & 0x00FF;
        }
        else
        {
            out[k++] = c2 & 0x00FF;
            out[k++] = c2 >> 8;
        }
    }

    return k;
}

/**
*  功  能: 将 GB2312 编码转成 UTF-8 编码
*  输  入: in       ----GB2312字串
*          inlen    ----GB2312字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----utf-8字串
*  返  回: >=0      ----转换后utf-8字串长度(字节数)
*          -1       ----转换出错
**/
int GBToUTF8(uchar *out, int outlen, uchar *in, int inlen)
{
    uchar *out1 = NULL;
    int   len = 0, len1 = 0, len2 = 0;

    len = (inlen < 0 ? 0 : inlen);
    len1 = 2 * len + 2;
    out1 = (uchar *)calloc(1, len1);
    if(NULL == out1)
    {
        LogMessage( "allot memory error!/n");
        return -1;
    }

    len1 = GBToUTF16(out1, len1, in, len);
    if(len1 <= 0)
    {
        free(out1);
        return len1;
    }

    len2 = outlen;
    len2 = UTF16ToUTF8(out, &len2, out1, &len1);
    free(out1);

    return len2;
}

/**
*  功  能: 将 fcode 编码转成 tcode 编码
*  输  入: fcode    ----源编码类型
*          tcode    ----目标编码类型
*          in       ----fcode类型编码字串
*          inlen    ----focde类型编码字串长度
*          outlen   ----输出缓冲区上限
*  输  出: out      ----tcode类型编码字串
*          outlen   ----tcode类型编码字串长度
*  返  回: >=0      ----转换后字串长度(字节数)
*          -1       ----转换出错
**/
int CodeConv(char *incode, char *outcode,uint8_t *out, int *outlen, uint8_t *in, int inlen)
{
    int len = 0, len1 = 0;

    if(NULL == incode || NULL == outcode) { *outlen = 0; return -1; }
    if(NULL == in) { *outlen = 0; out[0] = '/0'; return 0; }
    if(*outlen <= 0)  return (*outlen % 2);
    if(SetEndian() < 0) { *outlen = 0; return -1; }

    len = (inlen < 0 ? 0 : inlen);
    len1 = *outlen;

    if(strcasecmp(incode, "UTF-8")   != 0 &&
       strcasecmp(incode, "UTF8")    != 0 &&
       strcasecmp(incode, "UTF-16")  != 0 &&
       strcasecmp(incode, "UTF16")   != 0 &&
       strcasecmp(incode, "UNICODE") != 0 &&
       strcasecmp(incode, "GB2312")  != 0)
    {
        LogMessage( "Encoding [%s] is not supported/n", incode);
        return -1;
    }

    if(strcasecmp(outcode, "UTF-8")   != 0 &&
       strcasecmp(outcode, "UTF8")    != 0 &&
       strcasecmp(outcode, "UTF-16")  != 0 &&
       strcasecmp(outcode, "UTF16")   != 0 &&
       strcasecmp(outcode, "UNICODE") != 0 &&
       strcasecmp(outcode, "GB2312")  != 0)
    {
        LogMessage( "Ecoding [%s] is not supported/n", outcode);
        return -1;
    }

    /* GB2312 -> UTF-8 */
    if(strcasecmp(incode,  "GB2312") == 0 &&
      (strcasecmp(outcode, "UTF8")   == 0 ||
       strcasecmp(outcode, "UTF-8")  == 0))
    {
        len1 = GBToUTF8(out, len1, in, len);
    }
    /* UTF-8 -> GB2312 */
    else if(strcasecmp(outcode, "GB2312") == 0 &&
           (strcasecmp(incode,  "UTF8")   == 0 ||
            strcasecmp(incode,  "UTF-8")  == 0))
    {
        len1 = UTF8ToGB(out, len1, in, len);
    }
    /* GB2312 -> UTF-16 */
    else if(strcasecmp(incode,  "GB2312")  == 0 &&
           (strcasecmp(outcode, "UTF16")   == 0 ||
            strcasecmp(outcode, "UTF-16")  == 0 ||
            strcasecmp(outcode, "UNICODE") == 0))
    {
        len1 = GBToUTF16(out, len1, in, len);
    }
    /* UTF-16 -> GB2312 */
    else if(strcasecmp(outcode, "GB2312")  == 0 &&
           (strcasecmp(incode,  "UTF16")   == 0 ||
            strcasecmp(incode,  "UTF-16")  == 0 ||
            strcasecmp(incode,  "UNICODE") == 0))
    {
        len1 = UTF16ToGB(out, len1, in, len);
    }
    /* UTF-8 -> UTF-16 */
    else if((strcasecmp(incode,  "UTF8")    == 0  ||
             strcasecmp(incode,  "UTF-8")   == 0) &&
            (strcasecmp(outcode, "UTF16")   == 0  ||
             strcasecmp(outcode, "UTF-16")  == 0  ||
             strcasecmp(outcode, "UNICODE") == 0))
    {
        len1 = UTF8ToUTF16(out, &len1, in, &len);
    }
    /* UTF-16 -> UTF-8 */
    else if((strcasecmp(outcode, "UTF8")    == 0  ||
             strcasecmp(outcode, "UTF-8")   == 0) &&
            (strcasecmp(incode,  "UTF16")   == 0  ||
             strcasecmp(incode,  "UTF-16")  == 0  ||
             strcasecmp(incode,  "UNICODE") == 0))
    {
        len1 = UTF16ToUTF8(out, &len1, in, &len);
    }
    else
    {
        len1 = len;
        memcpy(out, in, len);
    }

    *outlen = (len1 < 0 ? 0 : len1);

    if(len1 < 0) return -1;

    return (*outlen);
}
int sessionAuditDecodeToURL(u_int8_t *inputstr,u_int32_t inputlen, u_int8_t *outputstr)
{
 char conv[] = "0123456789ABCDEF";
 u_int32_t i ;
 u_int8_t *d_ptr;
 u_int8_t *data;

 data = inputstr;
 d_ptr = outputstr;
 for(i = 0; i < inputlen; i++)
 {
  *d_ptr = conv[((*data & 0xFF) >> 4)];
  d_ptr++;

  *d_ptr = conv[((*data & 0xFF) & 0x0F)];
  d_ptr++;

  data++;
 }
 return 0;
}


#ifdef SAS3_10Q2_DECODE
//zxd change 20100315
int DecodeToURL(uint8_t *inputstr,u_int32_t inputlen, uint8_t *outputstr)
{
 int i;
 for (i = 0;i<inputlen;i++)
 {
  if (inputstr[i] == '/0')
  {
   outputstr[i] = '/0';
  }else if (inputstr[i] == '/'')
  {
   outputstr[i] = '"';
  }
  else if (inputstr[i] == '//')
  {
   outputstr[i] = '/';
  }
  else
   outputstr[i] = inputstr[i];
 }
 return 0;
}
#else
/*zxd change 20100222
 * URL decode
 *
 * */
int DecodeToURL(u_int8_t *inputstr,u_int32_t inputlen, u_int8_t *outputstr)
{
 char conv[] = "0123456789ABCDEF";
 u_int32_t i ;
 char *d_ptr;
 char *data;

 data = inputstr;
 d_ptr = outputstr;
 for(i = 0; i < inputlen; i++)
 {
  *d_ptr = conv[((*data & 0xFF) >> 4)];
  d_ptr++;

  *d_ptr = conv[((*data & 0xFF) & 0x0F)];
  d_ptr++;

  data++;
 }
 return 0;
}
#endif

utf.h：C用于C和C ++的单头utf8字符串函数
03-28
我们提供了一个名为utf.h的单个头文件，其中包含了C和C++的UTF-8字符串处理函数库。这个库包括ascString、ucsString和utfString类，以及用于各种字符串类型之间转换的utfCount、utf8_ucs2_t和utf8_ucs4_t工具。这些工具和类库使得在处理中文字符串时更加简单，包括字符类型之间的转换、操作和统计等功能，有助于简化中文软件的设计和输出过程。 其中包含字模库文件路径、字模宽度、字模高度、每个字模字节数和字模库文件缓存区 函数包括： enc_get_utf8_size(const unsigned char pInput) * 将一个字符的UTF8编码转换成Unicode(UCS-2和UCS-4)编码. enc_utf8_to_unicode_one(const unsigned char* pInput, unsigned long *Unic) * 将一个字符的UTF8编码转换成Unicode(UCS-2和UCS-4)编码. 等等
php中的字符编码转换函数用法示例
10-25
总之，`mb_convert_encoding()` 是PHP中处理字符编码转换的核心工具，通过它，你可以确保字符串在各种编码系统之间正确无误地转换，从而避免乱码问题。在编写PHP程序时，务必考虑到编码兼容性，确保数据在所有环节都...
ansi、Unicode、Utf-8之间的转化
游戏开发者
02-12 873
wstring ANSIToUnicode( const string& str ) { int len = 0; len = str.length(); int unicodeLen = ::MultiByteToWideChar( CP_ACP, 0, str.c_str(), -1, NULL, 0 ); wchar_t * pUnicode; pUnico
编码转换函数
yanjing2407的专栏
09-21 721
int main() { int length = 0; char* utf16xml = ReadFile("/home/project/iconv/utf16.xml",length); size_t inbuffer_length = length; char* inbuffer = new char[inbuffer_length+1]; memset(inbuffer,0,i
PHP判断字符集并转码的函数
hudeyong926的专栏
07-18 130
原理很简单，因为gb2312/gbk是中文两字节，这两个字节是有取值范围的，而utf-8中汉字是三字节，同样每个字节也有取值范围。而英文不 管在何种编码情况下，都是小于128，只占用一个字节（全角除外）。 如果是文件形式的编码检查，还可以直接check utf-8的BOM信息。话不多说，直接上函数，这个函数是用来对字符串进行检查和转码的。 <?php function safeEnc...
字符编码各种转换：utf8,unicode
pvlking的专栏
07-07 740
原帖地址：http://bbs.csdn.net/topics/320095332 #include "stdafx.h" #include #include using namespace std; #include "charsetCvt.h" string ws2s(const wstring& ws) { string curLocale = setlocale(LC_ALL,
字符编码格式的转换
yy2yy99的专栏
08-10 533
（1）将Unicode转换为UTF8格式： wchar_t * wsContent =L""; int nContentLen = WideCharToMultiByte(CP_UTF8, 0, wsContent, -1, NULL, 0, NULL, NULL); int nLen = nContentLen*sizeof(wchar_t); char * pCdata = new c...
php字符编码转换之gb2312转为utf8
12-19
`iconv`函数是PHP中用于字符编码转换的一个工具，其基本语法为`iconv(string in_charset, string out_charset, string str)`。`in_charset`参数代表源字符集，`out_charset`参数是目标字符集，`str`是要转换的字符串...
C语言字符编码转换UNICODE、GBK、UTF-8互相转换
最新发布
06-27
在C语言中，进行字符编码转换通常涉及到内存操作和位操作，因为C语言没有内置的字符串类或者编码转换函数。以下是一些基本步骤： 1. **读取原始编码**：首先，你需要读取源文件或字符串，确定其当前的编码格式。这...
Qt中的字符编码转换：UTF8、Unicode、GBK、ASCII、16进制字符、16进制数值
03-03
在Qt开发中，字符编码转换是一项关键任务，尤其是在处理跨平台和多语言支持时。本文主要探讨了在Qt中如何进行UTF8、Unicode、GBK、ASCII、16进制字符和16进制数值之间的转换。 首先，让我们简单回顾一下各种编码...
UTF8.rar_UTF8_字符编码转换
09-24
标题中的"UTF8.rar_UTF8_字符编码转换"暗示了这个压缩包文件主要涉及的是关于UTF-8字符编码转换的相关内容。UTF-8是一种广泛使用的Unicode字符编码方案，它可以表示Unicode标准中的所有字符，且在互联网上被普遍采用...
int与字符串的相互转换
abcxcold的博客
11-06 422
int与字符串的相互转换 #include <iostream > #include <sstream > #include <string > using namespace std; int main () { stringstream sstr; //--------int转string----------- ...
int与字符、字符串之间的转换
Note_creek的博客
08-31 2849
1、单个字符的转换 int 转char： #include &lt;iostream&gt; #include &lt;sstream&gt; using namespace std; int main() { int num; char ch; cin&gt;&gt;num; ch=num+'0'; cout&lt;&lt;ch&lt;&lt;en...
c/c++ 字符集 gbk/utf8互转，Ansi/Utf8互转 纯c实现跨平台
12-04
跨平台（windows Linux）是纯c实现 gbk/utf8互转，Ansi/Utf8互转，
c++string和int互转
sinat_32165273的博客
05-06 200
一、int转换成string 1. to_string函数 c++11标准增加了全局函数std::to_string: string to_string (int val); string to_string (long val); string to_string (long long val); string to_string (unsigned val); string to_string...
“”(十六进制值 0x1D)是无效的字符
weixin_30760895的博客
07-21 3389
加载或保存XML时引发的异常.System.ArgumentException: “”(十六进制值 0x1D)是无效的字符。 产生原因是xml文件中包含低位非打印字符造成的 处理方法：在产生xml文件的时候，过滤低位非打印字符 把一个字符串中的 低序位 ASCII 字符 替换成 字符 转换 ASCII 0 - 8 -> - 转换 ASCII 11 - 12 -&gt...
字符编码格式转换
wait for you...编程爱好者
07-12 151
[code="java"] package com.yohn.encoding.convert; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileFilter; import java.io.FileInputStream; ...
shell实现字符编码转换工具分享
09-15
本文主要介绍了一个使用shell脚本实现的字符编码转换工具，它支持在UTF-8和GBK之间进行转换。对于需要处理多语言文本或者在不同编码格式之间切换的开发者来说，这个工具非常实用。 首先，我们来看一下这个脚本的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值