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进制数，并大端格式输出
*如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;
}