c语言编写几个重要的函数

/****************************************************
一、字符串截取函数
****************************************************/

/* 1、 从字符串的左边截取n个字符，src为源字符串，dst为目的字符串，返回地址*/
char*  SplitLeft(char *dst,char *src, int n)
{
char *p = src;
char *q = dst;
int len = strlen(src);
if(n>len)
n = len;

while(n--)
*(q++) = *(p++);

*(q++)='\0';

return dst;
}

/* 2、 从字符串的中截取n个字符，n为长度，m为位置,src为源字符串，dst为目的字符串，返回地址*/
char*  SplitMid(char *dst,char *src, int n,int m)
{
char *p = src;
char *q = dst;
int len = strlen(src);
if(n>len)
n = len-m;
if(m<0)
m=0;
if(m>len)
return NULL;
p += m;
while(n--)
*(q++) = *(p++);
*(q++)='\0';
return dst;
}

/* 从字符串的右边截取n个字符,src为源字符串，dst为目的字符串，返回地址*/
char*  SplitRight(char *dst,char *src, int n)
{
char *p = src;
char *q = dst;
int len = strlen(src);
if(n>len)
n = len;
p += (len-n);
while(*(q++) = *(p++));

return dst;
}

/* 判断字符串中是否存在该字符，以及字符出现的次数*/
int SplitSize(char x,char * str)
{
int i=0;
int ret = 0;
for(;i<strlen(str);i++)
{
if(str[i] == x)
ret ++;
}

return ret;
}

/****************************************************
二、转换函数
****************************************************/

const char HEXCH[] = "0123456789ABCDEF";
/*将数字和26个字母转化成16进制的asscii码*/
unsigned char CharToHex(char chFrom)
{
if (chFrom>='0' && chFrom<='9')
{
return chFrom - '0';
}
else if (chFrom>='A' && chFrom<='Z')
{
return 0x0A + chFrom - 'A';
}
else if (chFrom>='a' && chFrom<='z')
{
return 0x0A + chFrom - 'a';
}
else
{
return 0;
}
}

/*将十六进制的字符串转换为数字表示*/
/* parse 4 digit hexadecimal number */
static unsigned parse_hex4(const char *str)
{
unsigned h = 0;
/* first digit */
if ((*str >= '0') && (*str <= '9'))
{
h += (*str) - '0';
}
else if ((*str >= 'A') && (*str <= 'F'))
{
h += 10 + (*str) - 'A';
}
else if ((*str >= 'a') && (*str <= 'f'))
{
h += 10 + (*str) - 'a';
}
else /* invalid */
{
return 0;
}
/* second digit */
h = h << 4;
str++;
if ((*str >= '0') && (*str <= '9'))
{
h += (*str) - '0';
}
else if ((*str >= 'A') && (*str <= 'F'))
{
h += 10 + (*str) - 'A';
}
else if ((*str >= 'a') && (*str <= 'f'))
{
h += 10 + (*str) - 'a';
}
else /* invalid */
{
return 0;
}
/* third digit */
h = h << 4;
str++;
if ((*str >= '0') && (*str <= '9'))
{
h += (*str) - '0';
}
else if ((*str >= 'A') && (*str <= 'F'))
{
h += 10 + (*str) - 'A';
}
else if ((*str >= 'a') && (*str <= 'f'))
{
h += 10 + (*str) - 'a';
}
else /* invalid */
{
return 0;
}
/* fourth digit */
h = h << 4;
str++;
if ((*str >= '0') && (*str <= '9'))
{
h += (*str) - '0';
}
else if ((*str >= 'A') && (*str <= 'F'))
{
h += 10 + (*str) - 'A';
}
else if ((*str >= 'a') && (*str <= 'f'))
{
h += 10 + (*str) - 'a';
}
else /* invalid */
{
return 0;
}
return h;
}

unsigned short int Str2HexByOneByte(char *pFrom)
{
unsigned short int nuint8Return = 0;
unsigned short int k = 0;

for (int i=7; i<0; i--)
{
k = CharToHex(pFrom[i]);
k <<= i;
nuint8Return += k;
}

return nuint8Return;
}

unsigned char BcdToHex(unsigned char nBcdData)
{
unsigned char temp;
temp=(nBcdData/16*10 + nBcdData%16);
return temp;
}

unsigned int HexToBcd(unsigned char nHexData)
{
unsigned char temp;
temp=(nHexData/10*16 + nHexData%10);
return temp;
}

void BcdToStr(char * dest,char * bcd,int bcdlength)
{
int i;
for(i=0;i<bcdlength;i++)
{
sprintf(dest+i*2,"%02X",(unsigned char)bcd[i]);
}
}

void HexToStr(char *pbDest, 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;
pbDest[i*2] = ddh;
pbDest[i*2+1] = ddl;
}
pbDest[nLen*2] = '\0';
}

int StrToHex(char *pFrom, unsigned char *pTo)
{
int i;
char *p;

i = 0;
p = pFrom;

while (1)
{
if (*p==0 || *(p+1)==0)
{
break;
}

*pTo = (CHAR2HEX(*p)<<4)|(CHAR2HEX(*(p+1)));

++pTo;
++p;
++p;
++i;
}

*pTo++ = 0;

return i;
}

int StrToHex2(char *lpszIn, int nLen)
{
int nRet = 0;
for(int i = 1; i <= nLen; i++)
{
if( *lpszIn >= 'A' && *lpszIn < 'Z')
{
nRet += (*lpszIn - '0' - 7) * ( pow(16, (nLen-i)) );
}
else if( *lpszIn >= 'a' && *lpszIn < 'z')
{
nRet += (*lpszIn - '0' - 39) * ( pow(16, (nLen-i)) );
}
else
{
nRet += (*lpszIn - '0') * ( pow(16, (nLen-i)) );
}
lpszIn++;
}
return nRet;
}

int AsciiToBcd( char *pDst, char *pSrc)
{
int nLen = (strlen(pSrc)+1)/2;
for (int i=strlen(pSrc)-1; i>0; i-=2)
{
int n1 = pSrc[i] - '0';
int n2 = pSrc[i-1] - '0';
pDst[i/2] = (n1&0xFF)|(n2<<4);
}
if (strlen(pSrc)%2 != 0)
{
pDst[0] = pSrc[0] - '0';
}

return nLen;
}
/*
*将int型数据转换成4个字节的16进制数
bb27
，并大端格式输出
*如int 10000转化为16进制2710，转化为0x00 0x00 0x27 0x10
*/
void EndianLocal2Big32(unsigned int nLocalData, unsigned char *pTo)
{
pTo[0] = (nLocalData >> 24) & 0xff;
pTo[1] = (nLocalData >> 16) & 0xff;
pTo[2] = (nLocalData >> 8) & 0xff;
pTo[3] = nLocalData & 0xff;
}
/*
*将int型数据转换成2个字节的16进制数，并大端格式输出
*如int 100转化为16进制64，转化为 0x00 0x64
*/
void EndianLocal2Big16(unsigned short int nLocalData, unsigned char *pTo)
{
pTo[0] = (nLocalData >> 8) & 0xff;
pTo[1] = nLocalData & 0xff;
}
/*
*将数组中的4个字节大端格式的16进制数，转化为int
*如：char pFrom={0x00,0x00,0x27,0x10};转化为int 10000
*/
unsigned int EndianBig2Local32(unsigned char *pFrom)
{
unsigned long ret;

ret = pFrom[0];
ret <<= 8;
ret |= pFrom[1];
ret <<= 8;
ret |= pFrom[2];
ret <<= 8;
ret |= pFrom[3];

return ret;
}
/*
*将数组中的2个字节大端格式的16进制数，转化为int
*如：char pFrom={0x00,0x64};转化为int 100
*/
unsigned short int EndianBig2Local16(unsigned char *pFrom)
{
unsigned short ret;

ret = pFrom[0];
ret <<= 8;
ret |= pFrom[1];

return ret;
}
/*
*将数组中的2个字节小端格式的16进制数，转化为int
*如：char pFrom={0x64,0x00};转化为int 100
*/
unsigned short int EndianLittle2Local16(unsigned char *pFrom)
{
unsigned short ret;

ret = pFrom[1];
ret <<= 8;
ret |= pFrom[0];

return ret;
}
/*
*将int型数据转换成2个字节的16进制数，并小端格式输出
*如int 100转化为16进制64，转化为0x64  0x00
*/
void EndianLocal2Little16(unsigned short int nLocalData, unsigned char *pTo)
{
pTo[0] = nLocalData & 0xff;
pTo[1] = (nLocalData >> 8) & 0xff;
}
/*
*将10进制转化为length长度的bcd码
*如：long 123456 length=4转化为00 12 34 56
*/
long DectoBCD(long Dec, unsigned char *Bcd, int length)
{
int i;
int temp;

for(i=length-1; i>=0; i--)
{
temp = Dec%100;
Bcd[i] = ((temp/10)<<4) + ((temp%10) & 0x0F);
Dec /= 100;
}
return 0;
}
/*
*将长度为length的BCD码转化为10进制数返回
*如：BCD 00 12 34 56 转化为long 123456
*/
unsigned long BCDtoDec(const unsigned char *bcd, int length)
{
int i, tmp;
unsigned long dec = 0;

for(i=0; i<length; i++)
{
tmp = ((bcd[i]>>4)&0x0F)*10 + (bcd[i]&0x0F);
dec += tmp * pow(100, length-1-i);
}
return dec;
}
/*
*将数字字符串转化为BCD
*如：sprintf(pSrc,"%s","123456");
*pDst= 12 34 56
*/
int AsciiToBcd( char *pDst, char *pSrc)
{
int nLen = (strlen(pSrc)+1)/2;
int i=strlen(pSrc)-1;
for (; i>0; i-=2)
{
int n1 = pSrc[i] - '0';
int n2 = pSrc[i-1] - '0';
pDst[i/2] = (n1&0xFF)|(n2<<4);
}
if (strlen(pSrc)%2 != 0)
{
pDst[0] = pSrc[0] - '0';
}

return nLen;
}