精华内容
下载资源
问答
  • C/C++处理十六进制数字符串

    万次阅读 2017-12-13 18:07:38
    原文站点:https://senitco.github.io/2017/06/07/string-processing/  C/C++处理十六进制数和字符串小结,包括十六进制数组和字符串的相互转换,二进制字符串十六进制数组的转换,不定长字符串的读取等。...

    原文站点:https://senitco.github.io/2017/06/07/string-processing/

      C/C++处理十六进制数和字符串小结,包括十六进制数组和字符串的相互转换,二进制字符串和十六进制数组的转换,不定长字符串的读取等。

    十六进制数组和字符串的相互转换

    例如 { 0x23, 0x3A, 0x46, 0x4C, 0x52 } <=> “233A464C52”

    /************************************************************************
    *   功能:将一个十六进制字节串转换成 ASCII 码表示的十六进制的字符串
    *   输入参数:pHex    -- 十六进制数字节串首地址
    *            pAscii -- 转换后的 ASCII 码表示的十六进制字符串的首地址
    *            nLen    -- 要转换的十六进制数的长度(字节数)
    *   输出参数:None
    *   注:  转换后的结果全部是大写 ASCII 表示的十六进制数
    ************************************************************************/
    void HexToAscii(unsigned char * pHex, unsigned char * pAscii, int nLen)
    {
        unsigned char Nibble[2];
    
        for (int i = 0; i < nLen; i++)
        {
            Nibble[0] = (pHex[i] & 0xF0) >> 4;
            Nibble[1] = pHex[i] & 0x0F;
            for (int j = 0; j < 2; j++)
            {
                if (Nibble[j] < 10)
                    Nibble[j] += 0x30;
                else
                {
                    if (Nibble[j] < 16)
                        Nibble[j] = Nibble[j] - 10 + 'A';
                }
                *pAscii++ = Nibble[j];
            }   // for (int j = ...)
        }   // for (int i = ...)
    }
    
    /****************************************************************************
    *   功能:将一个 ASCII 码表示的十六进制字符串转换成十六进制的字节串
    *   输入参数:pAscii -- 转换后的 ASCII 码表示的十六进制字符串的首地址
    *            pHex   -- 十六进制数字节串首地址
    *            nLen   -- 要转换的 ASCII 码表示的十六进制字符串的长度(字节数)
    *   输出参数:None
    *   注:  要求输入的 ASCII 码表示的十六进制数的字符个数必须为偶数,除了是1 - 9 和 A(a) - F(f) 以外没有别的字符
    ****************************************************************************/
    void AsciiToHex(unsigned char * pAscii, unsigned char * pHex, int nLen)
    {
        if (nLen % 2)
            return;
        int nHexLen = nLen / 2;
    
        for (int i = 0; i < nHexLen; i++)
        {
            unsigned char Nibble[2];
            Nibble[0] = *pAscii++;
            Nibble[1] = *pAscii++;
            for (int j = 0; j < 2; j++)
            {
                if (Nibble[j] <= 'F' && Nibble[j] >= 'A')
                    Nibble[j] = Nibble[j] - 'A' + 10;
                else if (Nibble[j] <= 'f' && Nibble[j] >= 'a')
                    Nibble[j] = Nibble[j] - 'a' + 10;
                else if (Nibble[j] >= '0' && Nibble[j] <= '9')
                    Nibble[j] = Nibble[j] - '0';
                else
                    return;
            }   // for (int j = ...)
            pHex[i] = Nibble[0] << 4;   // Set the high nibble
            pHex[i] |= Nibble[1];   //Set the low nibble
        }   // for (int i = ...)
    }

    十六进制数组和二进制字符串的相互转换

    例如 { 0x23, 0x4A, 0x5E } <=> “001000110100101001011110”

    /***十六进制数转换成二进制字符串***/
    void HexToBinStr(unsigned char* hexStr, unsigned char* binStr, int lenHex)
    {
        memset(binStr, '0', lenHex * 8);
        unsigned char hexChar[2];
        for (int i = 0; i < lenHex; i++)
        {
            hexChar[0] = (hexStr[i] & 0xF0) >> 4;
            hexChar[1] = hexStr[i] & 0x0F;
            for (int j = 0; j < 2; j++)
            {
                for (int k = 0; k < 4; k++)
                {
                    if (hexChar[j] & (0x08 >> k))
                    {
                        binStr[8 * i + 4 * j + k] = '1';
                    }
                }
            }
        }
    }
    
    /***二进制字符串转换成十六进制数***/
    void BinStrToHex(unsigned char* binStr, unsigned char* hexStr, int lenBin)
    {
        int lenHex = lenBin / 8;
        memset(hexStr, '\0', lenHex);
        unsigned char hexChar[2];
        for (int i = 0; i < lenHex; i++)
        {
            for (int j = 0; j < 2; j++)
            {
                hexChar[j] = 0;
                for (int k = 0; k < 4; k++)
                {
                    if (binStr[8 * i + 4 * j + k] == '1')
                    {
                        hexChar[j] |= (0x08 >> k);
                    }
                }
            }
            hexStr[i] = ((hexChar[0] & 0x0F) << 4) | (hexChar[1] & 0x0F);
        }
    }

    读取不定长字符串

    /*******************读取不定长字符串******************/
    unsigned char* getlineStr()
    {
        int nByte = 50;
        char * line = (char *)malloc(nByte), *linep = line;
        size_t lenmax = nByte, len = lenmax;
        int c;
    
        if (line == NULL)
            return NULL;
    
        for (;;)
        {
            c = fgetc(stdin);
            if (c == EOF)
                break;
    
            if (--len == 0)
            {
                len = lenmax;
                char * linen = (char *)realloc(linep, lenmax *= 2);
    
                if (linen == NULL)
                {
                    free(linep);
                    return NULL;
                }
                line = linen + (line - linep);
                linep = linen;
            }
    
            if ((*line++ = c) == '\n')
                break;
        }
        *--line = '\0';     //用'\0'替换掉换行'\n'
        return (unsigned char*)linep;
    }

    奇偶校验

    /***奇偶校验,使每个字节比特1的个数为奇数个***/
    void checkParity(unsigned char* srcChar, unsigned char* dstChar, int nLen)
    {
        unsigned char sinChar;
        short minBit = 0;
        short count = 0;
        for (int i = 0; i < nLen; i++)
        {
            count = 0;
            sinChar = srcChar[i];
            minBit = sinChar % 2;
            for (int j = 0; j < 8; j++)
            {
                if (sinChar % 2 == 1)
                    count++;
                sinChar >>= 1;
            }
            if (count % 2 == 1)
                dstChar[i] = srcChar[i];
            else if (minBit == 1)
                dstChar[i] = srcChar[i] - 1;
            else
                dstChar[i] = srcChar[i] + 1;
        }
    }

    字节填充(nByte字节的整数倍)

    /***********************************************************************************
    * 字节填充(8字节的整数倍)
    * 输入:binStr 二进制字符串; nByte 字节数
    * 返回:fillStr 填充后的字符串
    * 填充方法:在最右端填充一个‘1’位,之后再填充若干‘0’,直到该数据的最终字节数为 nByte 的整数倍
    ************************************************************************************/
    unsigned char* fillByte(unsigned char* binStr, int nByte)
    {
        int nBit = nByte * 8;
        int len1 = 0, len2 = 0;
        unsigned char* fillStr;
        unsigned char* tmpStr;
        if (strlen((const char*)binStr) % nBit == 0)
        {
            len1 = nBit;
        }
        else
        {
            len1 = nBit - strlen((const char*)binStr) % nBit;
        }
        len2 = strlen((const char*)binStr) + len1;
        tmpStr = (unsigned char*)malloc((len1 + 1) * sizeof(unsigned char));
        fillStr = (unsigned char*)malloc((len2 + 1) * sizeof(unsigned char));
        if (fillStr == NULL)
        {
            printf("allocation failture\n");
            exit(0);
        }
        memset(tmpStr, '0', len1);
        tmpStr[0] = '1';
        tmpStr[len1] = '\0';
    
        memcpy(fillStr, binStr, strlen((const char*)binStr));
        memcpy(fillStr + strlen((const char*)binStr), tmpStr, len1);
        fillStr[len2] = '\0';
    
        return fillStr;
    }

    以十六进制数形式读取文件

    文件是以字符形式读取的,因此需要转换为对应的十六进制数(例如”5C”->0x5C)

    /*****************单个字符转为数字('A'->10)*******************/
    static unsigned int hex_char_to_dec(char c)
    {
        if ('0' <= c && c <= '9')
        {
            return (c - '0');
        }
        else if ('a' <= c && c <= 'f')
        {
            return (c - 'a' + 10);
        }
        else if ('A' <= c && c <= 'F')
        {
            return (c - 'A' + 10);
        }
        else
        {
            return -1;
        }
    }
    
    /************两个字符转为一个16进制数("4B"->0x4B)**************/
    static unsigned int str_to_hex(const char *str)
    {
        return (str[1] == '\0') ? hex_char_to_dec(str[0]) : hex_char_to_dec(str[0]) * 16 + hex_char_to_dec(str[1]);
    }
    
    /*
    *对字符串inputString按tag字符分割
    *返回vector<string>格式的一维向量
    */
    vector<string> split(string inputString, char tag)
    {
        int length = inputString.length();
        int start = 0;//数值起始下标
        vector<string> line;
        for (int i = 0; i<length; i++)
        {
            if (inputString[i] == tag)
            {//遇到tag字符
                string sub = inputString.substr(start, i - start);    //取inputString[start]-inputString[i]子串
                line.push_back(sub);//压入向量中
                start = i + 1;
            }
            else if (i == length - 1)
            {
                string sub = inputString.substr(start, i - start + 1);//最后一个字符没有标点,需单独处理
                line.push_back(sub);//压入向量中
            }
        }
        return line;
    }
    
    /*
    *读取绝对路径为filePath的文件,文件中每行中的数值以tag字符分开
    *返回字节数
    */
    int readFile(char tag, string filePath, unsigned char* data)
    {
        ifstream fileReader;
        fileReader.open(filePath, ios::in);//以只读方式打开
        vector<vector<string>> vecData;//以2维向量的形势保持整个文件
        int i = 0;
        while (!fileReader.eof())
        {//未到文件末尾    
            string linestring;
            getline(fileReader, linestring);//读取一行
            vector<string> line = split(linestring, tag);//分割每行,并放在line向量中    
            for (vector<string>::iterator iter = line.begin(); iter != line.end(); iter++)
            {
                data[i] = str_to_hex(iter->c_str());
                i++;
            }
            vecData.push_back(line);
        }
        //return vecData;
        return i + 1;
    }
    展开全文
  • 1、数字转为字符串 let num=1256; let str="0x"+num.toString(16); console.log(str) 2、十六进制字符串解析为数字 let str="0xabc"; let num=parseInt(str) console.log(num)

    1、数字转为字符串

    let num=1256;
    let str="0x"+num.toString(16);
    console.log(str)

    2、十六进制字符串解析为数字

    let str="0xabc";
    let num=parseInt(str)
    
    console.log(num)

     

    展开全文
  • c# 浮点数十六进制字符串十六进制字符串数组转换为整数 (Converting array of hexadecimal strings to integers) Let suppose you have some of the strings (i.e. array of strings) containing hexadecimal ...

    c# 浮点数十六进制字符串

    将十六进制字符串数组转换为整数 (Converting array of hexadecimal strings to integers)

    Let suppose you have some of the strings (i.e. array of strings) containing hexadecimal values like "AA", "ABCD", "ff21", "3039", "FAFA" which are equivalent to integers 170, 43981, 65313, 12345, 64250.

    假设您有一些字符串(即字符串数组)包含十六进制值,例如“ AA”,“ ABCD”,“ ff21”,“ 3039”,“ FAFA” ,它们等效于整数170、43981、65313、12345, 64250

    As we have written in the previous post: convert hexadecimal string to integer, we use Convert.ToInt32() function to convert the values.

    正如我们在上一篇文章中所写的: 将十六进制字符串转换为integer ,我们使用Convert.ToInt32()函数转换值。

    We will access each item using a foreach loop, and convert the item to an integer using base value 16.

    我们将使用foreach循环访问每个项目,并使用基值16将其转换为整数。

    Code:

    码:

    using System;
    using System.Text;
    
    namespace Test
    {
        class Program
        {
            static void Main(string[] args)
            {
                string[] str = { "AA", "ABCD", "ff21", "3039", "FAFA"};
                int num = 0;
                try
                {
                    //using foreach loop to access each items
                    //and converting to integer numbers 
                    foreach (string item in str)
                    {
                        num = Convert.ToInt32(item, 16);
                        Console.WriteLine(num);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
    
                //hit ENTER to exit
                Console.ReadLine();
            }
        }
    }
    
    

    Output

    输出量

    170
    43981
    65313
    12345
    64250
    
    
    

    翻译自: https://www.includehelp.com/dot-net/print-integer-values-from-an-array-of-strings-containing-hexadecimal-values-in-c-sharp.aspx

    c# 浮点数十六进制字符串

    展开全文
  • 下面小编就为大家带来一篇c# 实现获取汉字十六进制Unicode编码字符串的实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 这时如果能把相关字符串用十六进制的形式打印出来,例如,”abc” 输出成 “\\x61\\x62\\x63” 这对于 i18n 的除错来说是很有帮助的。Python 里面,只需要使用 repr() 函数就行了。可在 C++ 中如何做到这点呢? 下面...
  • LabVIEW学习:十六进制和十六进制字符串相互转化

    万次阅读 多人点赞 2019-03-22 21:53:17
    在工作中经常会遇到发送十六进制...补充说明:十六进制更确切的说是十六进制整型,十六进制字符串就是通常所说的字符串。 在介绍转换前,首先说一下byte,在文本形式的编程语言中,byte占一个字节(八位二进制数据...

     在工作中经常会遇到发送十六进制,接收十六进制的问题。对于字符串大家肯定不会陌生,通常情况下我习惯了发送字符串数据,其实发送十六进制在实际使用中也是经常遇到的,在这里我将用LabVIEW实现十六进制和十六进字符串之间的转换。补充说明:十六进制更确切的说是十六进制整型,十六进制字符串就是通常所说的字符串。

    在介绍转换前,首先说一下byte,在文本形式的编程语言中,byte占一个字节(八位二进制数据),而一个十六进制由4个二进制。也就是两个十六进制可以组成一个byte。这方面的资料网上很多,在这里不再详细说。

    首先介绍对于功能实现两个核心函数:

    (1)数值至十六进制字符串转换 (函数),它使数字转换为十六进制数组成的字符串,至少为宽度个字符,还可依据需要适当加宽。A–F数位在输出字符串中始终大写显示。

       

               (2)十六进制数字符串至数值转换 (函数),它是从偏移量位置开始,使字符串中的下列字符:0-9、A-F、a-f解析为十六进制整型数据,通过数字返回。

    具体实现:

    (1)十六进制转十六进制字符串,具体实现如下图:

                

                 (2)十六进制字符串转十六进制,如下图:

               源码下载    提取码:jc53       (备注:采用是2015版32位NI LabVIEW开发)

    展开全文
  • QT 收到下位机16进制数转换字符串显示,绝对可靠 简单易懂。
  • ASCII转换成十六进制字符串和二进制字符串显示
  • 十六进制字符串“6B746d656d6f7869616667650007e26B” 有什么呢??在网络通信中,常常要制定一定的通讯格式。比如我制定,我要发送16字节的数据,其中前缀和后缀都是一字节为6B,中间为12字节的发送者姓名,加上...
  • // 此函数的作用是:“13”转为13,“0x0a”转为10 ... if(str.contains("0x")) // 如果这个字符串以0x开头,说明这是一个十六进制数,得按十六进制方式转 { num = str.toInt(&ok,10); } else .
  • 十六进制转换成字符串

    千次阅读 2011-09-30 11:26:25
    十六进制数怎么转化为中文字符 我调用别人封装好的一个函数从网络上接收数据,发现接收到的都是十六进制数据,本来接收到的应该是中文字符,我应该什么函数把十六进制数据转化为中文,屏幕上输出。   c或c++...
  • python十六进制字符串To assign a hexadecimal value in the string so that it can be printed as a string, we use \x that is known as Escape sequence”, it represents that given value is the hexadecimal ...
  • 最近在做一些**算法的处理,由于借鉴了许多已存在模块,处理时使用了许多字符串和进制...十六进制字符串转成十进制 二进制字符串转化为十六进制字符串 二进制字符串转化为十进制 十六进制字符串转成二进制串 ASC...
  • 1.十六进制数值转字符 1.1 0x31变为"31" 1.1.1 QByteArray原数据 //QByteArray转十六进制格式显示"1">>"31" 0x06>>"06" 10>>"0A" QByteArray data; QString ret(data.toHex().toUpper());//...
  • Java byte[] 字节数组 转 二进制 八进制 十进制 十六进制字符串
  • 写出一个程序,接受一个十六进制的数值字符串,输出该数值的十进制字符串。(多组同时输入 ) 输入描述: 输入一个十六进制的数值字符串。 输出描述: 输出该数值的十进制字符串。 输入例子: 0xA 输出例子: 10 ...
  • 加载或保存XML时引发的异常.System.ArgumentException:“”(十六进制值0x1D)是无效的字符。产生原因是xml文件中包含低位非打印字符造成的处理方法:在产生xml文件的时候,过滤低位非打印字符 把一个字符串中的低...
  • 关于蓝牙这一模块,确实是有一定难度的,如果想做得...扫描附近的蓝牙设备,显示蓝牙名称 手机与蓝牙设备的距离 界面如下: 蓝牙初始化 /** * 初始化蓝牙(onshow调用) */ bleInit: function () { let that = this
  • 题外话,回答主题:其实对计算机系统来说,没有什么十六进制字符字符在计算机中存储本身就是按一个一个编号来的,在计算机中也是二进制存储处理,注意,计算机也仅仅处理二进制,十六进制数仅仅是为了显示和人...
  • 十六进制转成十进制字符串显示

    千次阅读 2013-10-14 09:59:19
    2.再将十六进制字符串通过 “ ChangeNum ” 函数转成十进制;   3.最后通过gcvt函数再将十进制转成字符串 //ADC Value Display CString ADCVal,Temp; //接收数据转换成十六进制buffer ch
  • 事情起因就是我手头有好些文件都带有Unicode编码...嗯,很糟糕,这样是不能看的,所以我简单的写了个程序,自动转换一下带十六进制Unicode编码字符串文件,支持文件夹嵌套。没准以后还能着,就稍微整理了一下。impo
  • 输入一个十六进制字符串,以\n结束,输出其相应的十进制。 解:如16进制ABC化为10进制…… ABC(16)÷10 = 112 余 8 112(16)÷10 = 1B 余 4 1B(16)÷10 = 2 余 7 2(16)÷10 = 0 余 2 反向取余是2748(10...
  • QT十进制十六进制字符串转换

    万次阅读 多人点赞 2018-09-28 15:44:27
    QByteArray在串口通讯中经常被使用,有一定必要较为全面详细的对QByteArray进行阐述。本文通过以下几个部分加以介绍: 1. 初始化 2. 访问与赋值 3. 添加、删除、插入与替换操作 4. 查找与比较 5. 数据转换与...
  • labview 将字符串控件的数据转换成十六进制字符串,可用于Hex显示 使用Labview2015版本写的
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • QString str = QString("%1").arg(outChar&0xFF,2,16,QLatin1Char('0')); int a=0001; QString str = QString("%1").arg(a,4,10,QLatin1Char('0'));
  • 十六进制字符串转换为十进制

    万次阅读 2018-08-15 10:05:22
    十进制字符串转换为十进制 ...十六进制字符串转换为十进制 法一 long long change_num(char *str, int length) { char revstr[16] = {0}; //根据十六进制字符串的长度,这里注意数组不要越界...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,907
精华内容 37,962
关键字:

十六进制数用字符串显示