精华内容
下载资源
问答
  • 1 字符串转十六进制 代码实现: void StrToHex(char *pbDest, char *pbSrc, int nLen) { char h1,h2; char s1,s2; int i; for (i=0; i<nLen/2; i++) { h1 = pbSrc[2*i]; h2 = pbSrc[2*i+1]; s1 = ...

    1 字符串转十六进制

    代码实现:

    void StrToHex(char *pbDest, char *pbSrc, int nLen)
    {
      char h1,h2;
      char s1,s2;
      int i;
      for (i=0; i<nLen/2; i++)
      {
        h1 = pbSrc[2*i];
        h2 = pbSrc[2*i+1];
    
        s1 = toupper(h1) - 0x30; //toupper 转换为大写字母
        if (s1 > 9)
            s1 -= 7;
        s2 = toupper(h2) - 0x30;
        if (s2 > 9)
            s2 -= 7;
    
        pbDest[i] = s1*16 + s2;
      }
    }
    

    2 十六进制转字符串

    代码实现:

    void HexToStr(char *pszDest, char *pbSrc, int nLen)
    {
       char    ddl, ddh;
       for (int i = 0; i < nLen; i++)
       {
          ddh = 48 + pbSrc[i] / 16;
          ddl = 48 + pbSrc[i] % 16;
          if (ddh > 57) ddh = ddh + 7;
          if (ddl > 57) ddl = ddl + 7;
          pszDest[i * 2] = ddh;
          pszDest[i * 2 + 1] = ddl;
       }
       pszDest[nLen * 2] = '\0';
    }
    
    //或者:
    u16 Hex2StringArray (u8 *pSrc,  u16 SrcLen, u8 *pObj)
    {
       u16 i=0;
       for(i=0;    i<SrcLen;   i++)
       {
          sprintf((char *)(pObj + i * 2), "%02X", *(pSrc + i));
       }
       *(pObj + i * 2) = '\0';
       return  (i * 2);
    }
    //效果:十六进制"0x13 0xAA 0x02",转为字符串"13AAA2"。
    

    3 字符串转十进制

    //(1)若带负号,代码实现:
    int my_atoi(const char *str)
    {
       int value = 0;
       int flag = 1; //判断符号
       while (*str == ' ')  //跳过字符串前面的空格
       {
          str++;
       }
       if (*str == '-')  //第一个字符若是‘-’,说明可能是负数
       {
          flag = 0;
          str++;
       }
       else if (*str == '+') //第一个字符若是‘+’,说明可能是正数
       {
          flag = 1;
          str++;
       }//第一个字符若不是‘+’‘-’也不是数字字符,直接返回0
       else if (*str >= '9' || *str <= '0')
       {
          return 0;
       }
       //当遇到非数字字符或遇到‘\0’时,结束转化
       while (*str != '\0' && *str <= '9' && *str >= '0')
       {
          value = value * 10 + *str - '0'; //将数字字符转为对应的整形数
          str++;
       }
       if (flag == 0) //负数的情况
       {
          value = -value;
       }
       return value;
    }
    
    //效果:字符串"-123"转为"-123"。
    
    //(2)若不带负号,代码实现:
    void StrtoDec(uint32_t *pbDest, char *pbSrc, int nLen)
    {
       int i;
       int tmp=0;
       if(nLen > 10)
          *pbDest = 0;
       tmp = 1;
       *pbDest = 0;
       for (i=nLen-1; i>=0; i--)
       {
          *pbDest += tmp*(*(pbSrc+i)-'0');
          tmp = tmp*10;
       }
    }
    
    //效果:字符串"123"转为"123"。
    
    //(3)包含转为浮点数,代码实现:
    //m^n函数
    //返回值:m^n次方.
    u32 NMEA_Pow(u8 m,u8 n)
    {
       u32 result=1;
       while(n--)result*=m;
       return result;
    }
    //str转换为数字,以','或者'*'结束
    //buf:数字存储区
    //dx:小数点位数,返回给调用函数
    //返回值:转换后的数值
    int NMEA_Str2num(u8 *buf,u8*dx)
    {
       u8 *p=buf;
       u32 ires=0,fres=0;
       u8 ilen=0,flen=0,i;
       u8 mask=0;
       int res;
       while(1) //得到整数和小数的长度
       {
          if(*p=='-'){mask|=0X02;p++;}//是负数
          if(*p==','||(*p=='*'))break;//遇到结束了
          if(*p=='.'){mask|=0X01;p++;}//遇到小数点了
          else if(*p>'9'||(*p<'0'))   //有非法字符
          {
             ilen=0;
             flen=0;
             break;
          }
          if(mask&0X01)flen++;
         else ilen++;
         p++;
       }
       if(mask&0X02)buf++; //去掉负号
       for(i=0;i<ilen;i++) //得到整数部分数据
       {
          ires+=NMEA_Pow(10,ilen-1-i)*(buf[i]-'0');
       }
       if(flen>5)flen=5;   //最多取5位小数
       *dx=flen;           //小数点位数
       for(i=0;i<flen;i++) //得到小数部分数据
       {
          fres+=NMEA_Pow(10,flen-1-i)*(buf[ilen+1+i]-'0');
       }
       res=ires*NMEA_Pow(10,flen)+fres;
       if(mask&0X02)res=-res;
       return res;
    }
    
    //效果:字符串"123.456"先转为"123456",然后除以1000得到"123.456"。
    

    4 十进制转字符串

    u16 DectoStr (u8 *pSrc, u16 SrcLen, u8 *pObj)
    {
       u16 i=0;
       for(i=0;    i<SrcLen;   i++)
       {
          sprintf((char *)(pObj + i * 2), "%02d", *(pSrc + i));
        }
        *(pObj + i * 2) = '\0';
        return  (i * 2);
    }
    
    //效果:十进制数组"13 14"转为字符串"1314"。
    
    

    5 u8、u32转换

    字符‘A’ , 一个字节8bit ,即u8十六进制为0x41二进制为"0100 0001"。
    
    而对应的十进制为654个字节32bit,即u32十六进制为0x41二进制为"0000 0000 0000 0000 0000 0000 0100 0001"。
    
    (1)将u32数转换成u8数组
    
    注意:这里是字符数组,不是字符串;字符串是以空字符(\0)结尾的char数组。
    void U32ToU8Array(uint8_t *buf, uint32_t u32Value)
    {
       buf[0] = ((u32Value >> 24) & 0xFF);
       buf[1] = ((u32Value >> 16) & 0xFF);
       buf[2] = ((u32Value >> 8) & 0xFF);
       buf[3] = (u32Value & 0xFF);
    }
    
    效果:整型 50 转字符数组 {‘\0,’\0,’\0,2}。
    
    (2)u8数组转u32
    void U8ArrayToU32(uint8_t *buf, uint32_t *u32Value)
    {
       *u32Value = (buf[0] <<24) + (buf[1] <<16) + (buf[2] <<8) + (buf[3] <<0);
    }
    
    效果:字符数组 {‘\0,’\0,’\0,2}转为整型 50

    6 大端小端

    //STM32默认是小端模式,那么该如何转为大端?
    
    //代码实现:
    //为大端:
    pPack[0] = (u8)((len >> 8) & 0xFF);
    pPack[1] = (u8)(len & 0xFF);
    
    //为小端:
    pPack[0] = (u8)(len & 0xFF);
    pPack[1] =  (u8)((len >> 8) & 0xFF);
    
    //效果:len为数据类型为u16(short),比如0x11 0x22,转为u8(usigned char)数组。
    
    //大端为:
    pPack[0]0x11 )
    pPack[1]0x22//小端为:
    pPack[0]0x22)
    pPack[1]0x11
    展开全文
  • 主要介绍了javascript将16进制字符串转换为10进制整数hex,需要的朋友可以参考下
  • C语言 字符串16进制

    千次阅读 2018-12-19 10:22:39
     //16进制输出   for(i =0;i;i++)  {  printf("%x",a[i]);  printf("\n");  }  printf("\n");  //10进制输出   for(i =0;i;i++)  {  printf("%d",a[i]);  printf("\n");  }  return 0;...

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>

    int main()
    {
        char *str="12345678";
        int a[4];
        int i=0;
        for(i=0;i<4;i++)
        {
            sscanf(str,"%2x",&a[i]);
            str = str+2;
        }
        //16进制输出 
        for(i =0;i<4;i++)
        {
            printf("%x",a[i]);
            printf("\n");
        }
        printf("\n");
        //10进制输出 
        for(i =0;i<4;i++)
        {
            printf("%d",a[i]);
            printf("\n");
        }
        return 0;
    }

    展开全文
  • C语言进制字符串与十六进制字符串相互转化,利用MFC框架生成小工具。
  • C语言 字符串16进制数的互相转化

    千次阅读 2019-02-15 14:44:09
    16进制字符串: #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; int main() { int a[6] = {0x12,0x34,0x56,0x78,0xab,0xcd}; char *str = (char*)...

    16进制到字符串:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main()
    {
    	int a[6] = {0x12,0x34,0x56,0x78,0xab,0xcd};
    	char *str = (char*)malloc(32);
    	memset(str,0,32);
    	int i = 0;
    	for(i = 0; i < 6;i++)
    	{
    		sprintf(str,"%s%x",str,a[i]);
    	}
    	for(i = 0; i < strlen(str);i++)
    	{
    		printf("%c ",str[i]);
    	}
    	printf("\n%s\n",str);
    	return 0;
    }
    	

    字符串到16进制:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
    	/*char *str = (char *)malloc(6);
    	sprintf(str,"123456");*/
    	char *str = "123456";
    	int tmp;
    	int a[6]={0};
    	int i=0;
    	printf("%ld\n",strlen(str));
    	for(i = 0; i< 6; i++)
    	{
    		sscanf(str,"%1x",&a[i]);
    		printf("a[%d] = %2x \n",i,a[i]);
    		str++;
    	}
    	for(i = 0;i < 6;i++)
    	{
    		printf("a[%d] = %d \n",i,a[i]);
    	}
    	
    	return 0;
    }

     

    展开全文
  • 一、将数组转换为十六进制同值的字符串 读取数组中的数字,打印成字符串的时候以2位大写的格式。 1 int arrayToStr(unsigned char *buf, unsigned int buflen, char *out) 2 { 3 char strBuf[33] = {0}; 4 ...

    转载地址:https://my.oschina.net/u/4309414/blog/3613889

    一、将数组转换为十六进制同值的字符串

       读取数组中的数字,打印成字符串的时候以2位大写的格式。

      int arrayToStr(unsigned char *buf, unsigned int buflen, char *out)
      {
          char strBuf[33] = {0};
          char pbuf[32];
          int i;
          for(i = 0; i < buflen; i++)
          {
              sprintf(pbuf, "%02X", buf[i]);
              strncat(strBuf, pbuf, 2);
          }
          strncpy(out, strBuf, buflen * 2);
          printf("out = %s\n", out);
          return buflen * 2;
     }

    二、将十六进制的字符串转换为十六进制数组

    下面定义的字符串中的字符只能是0-F的字符,但是不区分大小写的,前面是安装两位为一个数字进行转换,最后一个数字如果还是两位的则正常转换,如果只剩一位的话则在前面补零输出。

     

      int StringToHex(char *str, unsigned char *out, unsigned int *outlen)
      {
          char *p = str;
          char high = 0, low = 0;
          int tmplen = strlen(p), cnt = 0;
          tmplen = strlen(p);
          while(cnt < (tmplen / 2))
          {
              high = ((*p > '9') && ((*p <= 'F') || (*p <= 'f'))) ? *p - 48 - 7 : *p - 48;
             low = (*(++ p) > '9' && ((*p <= 'F') || (*p <= 'f'))) ? *(p) - 48 - 7 : *(p) - 48;
             out[cnt] = ((high & 0x0f) << 4 | (low & 0x0f));
             p ++;
             cnt ++;
         }
         if(tmplen % 2 != 0) out[cnt] = ((*p > '9') && ((*p <= 'F') || (*p <= 'f'))) ? *p - 48 - 7 : *p - 48;
         
         if(outlen != NULL) *outlen = tmplen / 2 + tmplen % 2;
         return tmplen / 2 + tmplen % 2;
     }

    View Code

    三、将十进制字符串转化为十进制数组

      int StringToCom(char *str, unsigned char *out, int *outlen)
      {
          char *p = str;
          char high = 0, low = 0;
          int tmplen = strlen(p), cnt = 0;
          tmplen = strlen(p);
          if(tmplen % 2 != 0) return -1;
          while(cnt < tmplen / 2) //1213141516171819
          {
             out[cnt] = (*p - 0x30) * 10 + (*(++p) - 0x30);
             p++;
             cnt ++;
         }
         *outlen = tmplen / 2;
         return tmplen / 2;
     }

     

    四、简单的使用方法

    定义的参数有些为unsigned char,是因为在定义为char的时候,转换为十六进制之后,负数在表示的时候,难看!

      #include "stdio.h"
      #include "stdlib.h"
      #include "string.h"
      
      unsigned char ArrayCom[16] = {
          11, 12, 13, 14, 15, 16, 17, 18,
          19, 20, 21, 22, 23, 24, 25, 26};
      unsigned char ArrayHex[16] = {
          0x2c, 0x57, 0x8f, 0x79, 0x27, 0xa9, 0x49, 0xd3,
         0xb5, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     
     char *strHex = "01aa0304050607083f0add0c0d0e0f00";
     char *strCom = "1D1213AB6FC1718B19202122232425A6";
     
     int main(int argc, const char *argv)
     {
         int cnt;
         char str[33] = {0};
         unsigned char out[33];
         arrayToStr(ArrayCom, 16, str);
         
         int outlen = 0;
         StringToHex(strCom, out, &outlen);
         for(cnt = 0; cnt < outlen; cnt ++)
         {
             printf("%02X ", out[cnt]);
         } 
         putchar(10);
     
         return 0;
     }
    展开全文
  • c语言字符串转10进制或者16进制

    千次阅读 2019-06-27 15:11:55
    直接上语句; str = “16” 1,字符串16进制 int a = strtol(str,NULL,16); 2,字符串转10进制 int b = strtol(str,NULL,10); 或者: int b = atoi(str); ...
  • Dll 文件里面实现了字符串转为十六进制的数,请调用头文件,根据自己的需要使用
  • 1、字符串16进制 // parameter(s): [OUT] pbDest - 输出缓冲区 // [IN] pbSrc - 字符串 // [IN] nLen - 16进制数的字节数(字符串的长度/2) // remarks : 将字符串转化为16进制数 void str_to_hex(char *pbDest, ...
  • 字符串转换16进制或者10进制:1、使用自己编写的函数。2、使用库函数。 将字符串转换16进制两种方法的代码: #include #include #include  int HexStr2Int(char *buf)  { int result = 0; int tmp...
  • C语言 文本字符串和十六进制形式的相互转换 一、简述 记--C语言实现 文本形式的字符串和十六进制字符串的相互转换。如"01" <==> "3031" 有的数据包含不可见字符,直接打印出来会不可见或残缺,需要转换为...
  • //字符个数双数,小写 char cBrr[6] = {0xa1, 0xb2, 0xc3, 0xd4, 0xe5, 0xf6}; 调用函数,参数1传入cArr, 参数2传入cBrr unsigned int persist_ssl_hashKeyConvert(char *pUserInput, char *pKeyArra...
  • C语言字符串转为16进制

    万次阅读 2019-05-18 08:49:01
    // [IN] nLen - 16进制数的字节数(字符串的长度/2) // return value: // remarks : 将字符串转化为16进制数 */ void StrToHex(unsigned char *pbDest, unsigned char *pbSrc, int nLen) { char h1,h2; unsigned ...
  • 所以,在转换的时候往往费力费时,近日做项目正好用到和java程序通讯,java发送过来的数据是十六进制数字组成的字符串,解析的时候颇费心思才算完成,所以,权在此做一笔记,方便以后查看,以及需要帮助的童鞋,当然...
  • #include <stdio.h> #include <stdlib.h> typedef unsigned char BOOL_T; typedef unsigned char U8_T; typedef signed char S8_T;...typedef unsigned short U16_T; typed...
  • C语言十六进制字符串转换进制

    万次阅读 2018-10-08 17:32:23
    简单的十六进制转换,用到了大小写字符转换、计算指数。 /* * 十六进制转换进制 */ void htoi(char s[]); void practice2_3(); void main() { practice2_3(); } void htoi(char s[]){ int totalNum = 0; int...
  • 16进制字符串

    2019-03-13 20:41:30
    16进制字符串
  • 有的通信模块不支持二进制形式进行透传,需要MCU事先将二进制数据转换为十六进制字符串形式发送。比如,MCU需要发送的数据为0x1234,但通信模块只能接受字符串形式,因此必须要将其转换字符串形式的"1234",...
  • 改进:转换后可以放在原数组里,以节约资源。 #include <...//把16进制src字符串转为16进制数组dest 比如:“1234” {0x12,0x34} 返回长度 unsigned int HexStringtoByte(char *dest, char ...
  • c语言-10进制字符串16进制字符串

    千次阅读 2018-10-08 12:42:26
    printf("-------------16进制字符串----------\n"); printf("%s\n", DecToHex(pHex,Dec,strlen(Dec))); printf("\n\n\n"); } 代码2-非动态分配: #include #include #include char *DecToHex(char *...
  • 参与公司的web server项目时,在与网页的信息处理中,要将12个字节的字符串例如“012a3b4d5e6f”,转换为十六进制数0x01,0x2a,0x3b,0x4d,0x5e,0x6f #define uint8_t unsigned char #define BUILD_UINT8(loByte, ...
  • 代码1:十六进制字符串函数 1 #include<stdio.h> 2 #include<string.h> 3 #include<ctype.h> 4 void Hex2Byte(const char* source, unsigned char* dest, int sourceLen) 5 { ...
  • C语言 转换10进制为16进制

    千次阅读 2020-01-01 16:58:07
    实际上就是除16取余然后将其本身除以16,得到的这一个数将它转换为具体的16进制数字的过程,当然最后还要注意前面的字符位置的添加 /* 进制之间互相转换:将十进制数字转换为十六进制,并将转换后的数字存储在...
  • 先使用strtol函数将字符串转成十进制数,再通过sprintf函数将十进制数按十六进制字符串形式输出到字符数组保存 该方案弊端:转换的数不能大于0x7FFFFFFF,因为strtol的返回值是long型 #include <stdio.h> #...
  • C语言 -- 字符串和十六进制的相互转换方式

    万次阅读 多人点赞 2018-10-17 16:53:21
    所以,在转换的时候往往费力费时,近日做项目正好用到和java程序通讯,java发送过来的数据是十六进制数字组成的字符串,解析的时候颇费心思才算完成,所以,权在此做一笔记,方便以后查看,以及需要帮助的童鞋,当然...
  • C语言如何将字符串转十六进制

    万次阅读 多人点赞 2019-06-30 14:39:26
    'A'对应的十六进制是0x41,'f'对应的十六进制是是0x66,'F'对应的十六进制是0x46,'0'对应的十六进制是是0x30,'9'对应的十六进制是0x39,其实这里的十六进制就是由字符对应的ASCII码转换得来的,下面主要讲下如何将...
  • 16进制字符串相互转换C语言

    千次阅读 2019-10-25 16:17:15
    字符串转换16进制函数 先写一个字符转大写的函数lowtocap (也可以直接调用C库函数toupper,需#include <ctype.h>) /*lowercase letters transform to capital letter*/ char lowtocap(char c) { ...
  • 字符串转为十六进制,利用snprintf转换str的格式。 下面贴上代码实现。 #include <stdio.h> void test_printf5(char *str,int length) { int iii; printf("the str is:"); for(iii= 0;iii <...
  • C语言 实现16进制 转换10进制

    千次阅读 2020-03-19 00:16:31
    原理:2、8或16进制转换成10进制都是用对应的进制数从后向前(从个位向前)依次乘以对应进制数的增长幂数然后求和。 例如16进制转10进制 : ABC=10*16^2+11* 16^1+12*16^0=2748 代码: #define _CRT_SECURE_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,090
精华内容 18,836
关键字:

c语言字符串转换16进制

c语言 订阅