C语言常用的几个工具函数详解

2024-11-26 16:31| 查看: 164| 评论: 0

摘要: 1、字符串转十六进制代码实现： void StrToHex(char *pbDest, char *pbSrc, int nLen) { char h1,h2; char s1,s2; int i;, for (i=0; inLen/2; i++) { h1 = pbSrc; ...

1、字符串转十六进制代码实现：

void StrToHex(char *pbDest, char *pbSrc, int nLen)$
{
  char h1,h2;
  char s1,s2;
  int i;,

for (i=0; i% _. ^& i. ?, G& d7 L) E9 K
{
      h1 = pbSrc[2*i];
      h2 = pbSrc[2*i+1];
: M/ F# b# l% K8 N
      s1 = toupper(h1) - 0x30; //toupper 转换为大写字母
      if (s1 > 9)
         s1 -= 7;* ~) H5 z! U$ a- w5 _
      s2 = toupper(h2) - 0x30;$ w$ i7 p% e* z8 Q0 t0 T- l
      if (s2 > 9)4 x5 |0 `4 V, _0 }2 m( S2 \
         s2 -= 7;
# i8 }' C5 G6 X! e
      pbDest = s1*16 + s2;
}3 V: s+ ~3 h0 u2 P5 d$ ]0 v
}

2、十六进制转字符串8 Y( u5 r4 {2 w* B, y; I
: c7 F) Y9 `( d7 s4 j; |6 T
代码实现：# v3 }6 e1 Q  b0 F$ y
( _- k7 [' p; `8 q  \+ l# w
0 Q4 _$ X; g% g. Z& F( f
void HexToStr(char *pszDest, char *pbSrc, int nLen)
{6 `7 K4 J/ L2 K4 ]/ i  j' Y9 [1 W
char ddl, ddh;
for (int i = 0; i < nLen; i++)
{$ F# ~" s2 l" D! S. t, m
      ddh = 48 + pbSrc / 16;
      ddl = 48 + pbSrc % 16;2 T4 ?0 t. m! p# y/ [7 P& ^
      if (ddh > 57) ddh = ddh + 7;
      if (ddl > 57) ddl = ddl + 7;9 [: c) b3 y9 N( J/ {
      pszDest[i * 2] = ddh;
      pszDest[i * 2 + 1] = ddl;8 X0 }2 i: ~" h7 G' V) V9 }7 ?" _
}
pszDest[nLen * 2] = '\0';
}

或者

u16 Hex2StringArray (u8 *pSrc,  u16 SrcLen, u8 *pObj)
{$ W' N% |2 y9 J3 K4 _
u16 i=0;9 ^$ ~! d. M8 k7 {, {

for(i=0; i {* ^4 T6 f0 l! `% J* U  i! K# G
      sprintf((char *)(pObj + i * 2), "%02X", *(pSrc + i));! |( h# g0 u; \7 P
}6 k0 V! h1 i( A& H: L3 e! R
*(pObj + i * 2) = '\0';
return  (i * 2);
}8 s3 a+ }' R' P3 a! `

  u; l9 Y+ z% _5 r# q2 f: Q
效果：十六进制：0x13 0xAA 0x02转为字符串：”13AAA2”
* d& y# g5 k9 f0 E, j8 E$ H

3、字符串转十进制$ a( x4 e. @1 |4 E- U

代码实现：% j3 s  \5 o) L! |9 e

第一种，如果带负号这个就是atoi函数的实现：

int my_atoi(const char *str)
{6 t% |5 Z# V2 P+ J/ z# C& }+ i
int value = 0;
int flag = 1; //判断符号
while (*str == ' ')  //跳过字符串前面的空格
{( |/ u/ t- D& j0 L
      str++;
}
if (*str == '-')  //第一个字符若是‘-’，说明可能是负数# u% n4 i( U% }+ h2 P
{" i7 }$ g% x5 R# X4 K
      flag = 0;
      str++;! i1 ?7 Z7 P3 g* n/ C
}* k5 Q. H2 u7 L3 J. o4 @
else if (*str == '+') //第一个字符若是‘+’，说明可能是正数
{
      flag = 1;1 F# A* G8 g" C5 \
      str++;
}//第一个字符若不是‘+’‘-’也不是数字字符，直接返回0
else if (*str >= '9' || *str <= '0')
{
      return 0; 9 Y1 ?, b' `6 `; W  S  p
}' g, y- ?% E3 B0 j' m
//当遇到非数字字符或遇到‘\0’时，结束转化4 b" d* t7 \6 I' j# t
while (*str != '\0' && *str <= '9' && *str >= '0')
{4 s% d, J- A7 N" M6 X- f
      value = value * 10 + *str - '0'; //将数字字符转为对应的整形数' f: |6 J0 o+ y# f
      str++;
}
if (flag == 0) //负数的情况
{, ~$ E3 v4 ]/ x, S
      value = -value;
}8 \5 f" u, o; T
return value;
}( `" \/ h5 V- p' w* |8 n3 {
7 S' U0 X  a2 \) r: J: @4 F/ S* }

效果：字符串：”-123” 转为 -1231 s, p+ [9 s" x  l

+ o" C: J5 F8 u7 \, O
第二种，如果不带负号：3 }7 x# w8 Y4 t5 ?& c

void StrtoDec(uint32_t *pbDest, char *pbSrc, int nLen)0 x" C3 f# R; y  S% ?0 Z
{& N# m' G& r% r9 R, b5 h
int i;
int tmp=0;! I+ N6 Y4 {% e7 J3 x. @; ~! X
if(nLen > 10), _3 b% {% N& [& w6 w4 i$ e
      *pbDest = 0;
tmp = 1;; ^5 W) q' j& \% c& {( F& p( G& j
*pbDest = 0;
for (i=nLen-1; i>=0; i--)
{0 P" ?& T" K) e
      *pbDest += tmp*(*(pbSrc+i)-'0');" p, ^# G5 q' `1 A
      tmp = tmp*10;/ Z; _# X& O7 L9 \
}
}

效果：字符串：”123” 转为 123

8 x5 B5 z, L) p6 A# K
第三种：包含转为浮点数：
$ y7 P5 }0 D3 d0 Y5 j
& Y" u% [9 K0 L0 ]
//m^n函数
//返回值:m^n次方.
u32 NMEA_Pow(u8 m,u8 n)# X- C% Y* i5 i9 {: I0 n
{
u32 result=1; . M; }9 ?5 X7 l( ~
while(n--)result*=m; + C; I, E, c" s5 }4 D7 u
return result;
}
//str转换为数字,以','或者'*'结束+ ?" t1 S. Q5 Z" J% F! q- E( {
//buf:数字存储区4 @" o: O: S( G- E$ Y+ V2 w
//dx:小数点位数,返回给调用函数
//返回值:转换后的数值& n7 w1 ~8 q; A7 T% d
int NMEA_Str2num(u8 *buf,u8*dx)& g- F" B/ `0 g; F0 q: f
{
u8 *p=buf;9 l% _" N) |, @; E" O8 F
u32 ires=0,fres=0;
u8 ilen=0,flen=0,i;  n* M: u+ n; c! ]# e
u8 mask=0;
int res;
while(1) //得到整数和小数的长度
{, B; V! U) A3 h' S. s+ [$ s
      if(*p=='-'){mask|=0X02;p++;}//是负数
      if(*p==','||(*p=='*'))break;//遇到结束了
      if(*p=='.'){mask|=0X01;p++;}//遇到小数点了
      else if(*p>'9'||(*p<'0')) //有非法字符3 S' I3 C! z3 B. R% ^( q+ H6 q
      { 0 Y4 z" |$ D4 F# v% M' m0 ~
         ilen=0;' z6 K2 L/ J4 _. j' y$ m# |4 m8 w
         flen=0;0 i, M, p! W# `7 p8 _# B7 P
         break;- K* _( }2 L& F
      }
      if(mask&0X01)flen++;' W% U2 `' ?$ k  K9 r# s7 T' y2 |
      else ilen++;
      p++;
}. {0 D- @9 w, n) g: ?
if(mask&0X02)buf++; //去掉负号
for(i=0;i {  9 O( c* w% x8 O5 V8 g' A
      ires+=NMEA_Pow(10,ilen-1-i)*(buf-'0');- ^" }3 X8 ~6 k0 a, T
}
if(flen>5)flen=5; //最多取5位小数, [" s# P& E% \% R& y0 n
*dx=flen;          //小数点位数
for(i=0;i" U$ {  w1 ^3 m" \- d" A# G! N( L
{
      fres+=NMEA_Pow(10,flen-1-i)*(buf[ilen+1+i]-'0');- V8 P; M) L# K' k5 h
} * h4 v. r! O2 v; N" J" x
res=ires*NMEA_Pow(10,flen)+fres;
if(mask&0X02)res=-res;
return res;
} : {; c# o# H5 S! {

效果：字符串：”123.456” 先转为 123456，然后除以1000得到123.456" n5 ^0 P) f% @
% b8 |' u0 ]: k/ [' s% t  ?  Z

4、十进制转字符串5 f5 M# g3 m) R

6 u: ?1 a  n* Z# i7 g
2 v5 _4 J! K' i
代码实现：

5 V0 N, D# f0 G; q" C
如果只是单个十进制转字符串，使用sprintf函数就可以了。$ u" i" B; U+ f" f, Q

如果是十进制数组：2 ~7 h8 l, k" a* L( z0 I* E

/ A% _) E! j1 v- G/ k
u16 DectoStr (u8 *pSrc, u16 SrcLen, u8 *pObj)
{
u16 i=0;& Q! n. e% K# J; ]. \
) T/ m, w, K* [" H! z. b: a
for(i=0; i: T+ V4 i% Y7 o6 p4 d1 Z
{; H5 K) C7 I/ S+ \# c3 f
      sprintf((char *)(pObj + i * 2), "%02d", *(pSrc + i));
}5 h  }( Y( n. x6 i' f' h
*(pObj + i * 2) = '\0';
return  (i * 2);, h7 q0 v$ }8 u* H& i
}- P7 E! M- P2 Q1 |
. O& v) N2 U: t
7 N- X; ^- M; j0 ?- [
效果：十进制数组13 14转为字符串“1314”
2 q- }2 [' H7 c$ ?2 C
( N+ a5 a# W2 q

5、u8、u32转换
5 |. K# R4 \; y4 s. g# n3 t
$ U- m- h' h" d( e
7 c; x; D4 L0 m3 @, W
举个栗子：ASCII码里

8 Y5 r& n# `9 f! V5 X/ o: v3 Q

( [" P3 D, K' c4 S3 e% w) Y

4 G& M6 ~* |( I
这里写图片描述字符‘A’ ，一个字节8bit ，即u8 十六进制为 0x41 二进制为 0100 0001

而对应的十进制为 65 整型65，4个字节32bit，即u32 十六进制为 0x41 二进制为 0000 0000 0000 0000 0000 0000 0100 0001
; `8 O7 [7 S- f# V

将u32数转换成u8数组

9 [  T: f# w) \  ]# E( n
注意：这里是字符数组，不是字符串
0 W; e$ g; R9 b# N& C. d

字符串是以空字符(\0)结尾的char数组
  H$ k9 P1 {# S- r1 G
( a, @* T' z) C, b, S+ Q! e
void U32ToU8Array(uint8_t *buf, uint32_t u32Value){
buf[0] = ((u32Value >> 24) & 0xFF);
buf[1] = ((u32Value >> 16) & 0xFF);7 u- q: ~9 {! |9 p0 r- u4 v
buf[2] = ((u32Value >> 8) & 0xFF);4 N' u5 k  t7 f0 K
buf[3] = (u32Value & 0xFF);' x4 u7 Q) g( f) L: @1 a9 B
}
- Y3 Y/ a, X; q. q5 I

效果：整型 50 转字符数组 {‘\0’,’\0’,’\0’,’2’}0 `: G! ^( o/ g. q. |& h, z

6 A, N; i# O% M* }6 R) n$ u
u8数组转u320 S9 _+ z" G6 }  }1 e- J! Y6 X& `

void U8ArrayToU32(uint8_t *buf, uint32_t *u32Value)7 C8 [! e8 G$ |' `) H
{
*u32Value = (buf[0] <<24) + (buf[1] <<16) + (buf[2] <<8) + (buf[3] <<0);
}9 V9 W2 g0 C  I6 L- S

, C7 |  P5 P( Z+ e! ?' I; ~- `
效果：字符数组 {‘\0’,’\0’,’\0’,’2’}转为整型 50
8 ^; t7 n, Q( l, B1 A
. ?. ^/ B( W2 u8 }7 _

6、大端小端8 n/ I1 v0 @  }0 t

2 n! ?$ ]1 q. ^% z
* j& n& l9 i6 X% w( O  v7 v( [
最后就是大小端问题了。STM32 默认是小端模式的，那么该如何转为大端？
2 W" x* _9 \) T2 A

1、转为大端
1 w  O" g$ m4 `% J, ]. @# c+ r/ `

为大端：
pPack[0] = (u8)((len >> 8) & 0xFF);2 }2 e' L& J0 \' j; M
pPack[1] = (u8)(len & 0xFF);' n( e; G# p* h

为小端：( P3 j" B; Q' c/ q
pPack[0] = (u8)(len & 0xFF);+ T4 ~+ A+ [  p/ U( U/ Y& j9 H
pPack[1] =  (u8)((len >> 8) & 0xFF);" e; I4 \& D2 L! ~5 Z9 m5 F
9 a' V8 \3 t- {; s) P- y$ L- A( p5 K

效果：len为数据类型为 u16（short），比如 0x11 0x22，转为u8（usigned char）数组。

3 \" W+ `$ i% y! I
大端为：
# `4 W1 Z, t: h

pPack[0] （0x11 ）
pPack[1] （0x22） ( z* k) {& l) D
+ F7 K4 Q1 n0 @- o: D) U

小端为：

) [- |8 r5 \) N9 [7 q! t: O
pPack[0] （0x22） , Q2 R5 \: R" k2 ^2 V
pPack[1] （0x11）

本站资讯文章系编辑转载，转载目的在于传递更多信息，并不代表本站赞同其观点和对其真实性负责。如涉及作品内容、版权和其它问题，请在30日内与本站联系，我们将在第一时间删除内容！
[声明]本站文章版权归原作者所有内容为作者个人观点本站只提供参考并不构成任何投资及应用建议。
本站拥有对此声明的最终解释权。

收藏邀请

上一篇：布线常用规则

下一篇：滤波电容真的是越大越好吗？

帐号		自动登录	找回密码
密码			注册

C语言常用的几个工具函数详解

最新文章

热门文章

推荐内容 /1