c 常用自定义函数

原文地址： http://www.linuxany.com/archives/914.html

//1.字符串大小写转换函数
char * ConversionString(char* _pDest, const char * _pSrc, int _nFlag);
//2.将字符串转换为整数
int CharToInt(const char* _pStr);
//3.将字符串转换成数字
double CharToDouble(const char* str);
//4.将整型数字转换为字符串,(正负数都可以)
char * IntToChar(char* pDestStr, int nSrcNum);
//5.将浮点型数字转换为字符串,(正负数都可以)
char * DoubleToChar(char* pDestStr, double dSrcNum);
//6.将字符串形式表示的 IP 转换为一个整数
int CharToIp(const char* _pchIP);
//7.将一个整数转换为一个IP字符串
char * IpToChar(const int nIP, char * _pchStrIP);
//8.将字符串 pStr 中所有的 ch字符过滤掉
char * StringFilter(char * pStr, const char ch);
//9.字符串替换函数, 在字符串 _pSrc 中查找 _pKey 串,并将其替换成 _pReplace 串
char * StringReplace(char* _pDest, const char* _pSrc, const char* _pKey, const char* _pReplace);
//10.从字符串 _PSrc 中查找 _Pkey, 如果找到,返回第一个找到的地址
char * StringFind(char* _pSrc, const char* _pKey);
//11.测试字符串是否是一个数字串
int IsNumberString(const char* _pStr);
//12.将字符串 _pchSrc 到序反转
char * StringReverse(char* _pchDest, const char* _pchSrc);

/*1
*    定义函数 char * ConversionString(char* _pDest, const char * _pSrc, int _nFlag);
*    表头文件 #include<assert.h>
*    函数描述    字符串大小写转换函数。
*                        此函数从第一个字符开始转换，遇到字符串结束时('\0')才结束转换。
*                        _pSrc 要转换的字符串首地址
*                        _pDest 转换后的字符串首地址, _pDest要有足够的空间来容纳转换后的字符串
                        _nFlag = 0, 大写转小写，小写转大写，其他字符不变
                        _nFlag = 1, 全部转换为小写，其他字符不变
                        _nFlag = 2 , 全部转换为大写，其他字符不变
                        _nFlag 取其他值是，函数返回 NULL
*     返回值 成功，返回 _pDest 的字符串起始地址。错误，返回NULL
*/
char * ConversionString(char* _pDest, const char * _pSrc, int _nFlag)
{
    assert( NULL != _pSrc && NULL != _pDest );
    char * pFirst = _pDest;
   
    if( 0 != _nFlag || 1 != _nFlag && 2 != _nFlag )
    {
        return NULL;
    }
       
    while( '\0' != *_pSrc )
    {
        if( *_pSrc >= 'a' && *_pSrc <= 'z' && 0 == _nFlag )
        {
            *_pDest++ = *_pSrc++ - 32;
        }
        else if( *_pSrc >= 'A' && *_pSrc <= 'Z' && 0 == _nFlag )
        {
             *_pDest++ = *_pSrc++ + 32;
        }
        else if( *_pSrc >= 'A' && *_pSrc <= 'Z' && 1 == _nFlag )
        {
             *_pDest++ = *_pSrc++ + 32;
        }
        else if( *_pSrc >= 'a' && *_pSrc <= 'z' && 2 == _nFlag )
        {
            *_pDest++ = *_pSrc++ - 32;
        }
        else
        {
            *_pDest++ = *_pSrc++;
        }
    }
    _pDest = NULL;
    _pSrc = NULL;
    return pFirst;
}

/*2
*    函数原形    int CharToInt(const char* _pStr);
*    表头文件    #include<assert.h>
*    函数描述    将字符串转换为整数，_pStr串中不能有 '+'、'-' 和 '.'，不支持小数和负数，
*                        此函数从第一个字符开始转换，遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。
*        参 数    _pStr，要转换为整数的字符串，只能是由'0' 到'9'之间的字符组成的字符串。
*     返回值    成功，返回转换后的整数。
*                        失败，返回 -1
*        备 注    _pStr 字符串中的空格可以被过滤掉，_pStr中可以存在空格, 当传入"" 或 " " 时，
*                        函数将返回 0
*/
int CharToInt(const char* _pStr)
{
    assert( NULL != _pStr );
 
    int nNumber = 0;
 
    while( '\0' != *_pStr )
    {
        if( ' ' == *_pStr )
        { 
            // 过滤空格字符
 
        }
        else if( *_pStr < '0' || *_pStr > '9')
        {
            // 如果遇到非'0'--'9' 之间的字符,直接返回
 
            return (-1);
        }
        else
        {
            nNumber = nNumber*10 + (*_pStr -48);
        }
        _pStr++;
    }
 
    return nNumber;
}

/*3
*    定义函数 double CharToDouble(const char* str);
*    表头文件 #include<assert.h>
*    函数描述    将字符串转换成数字，支持整数、小数、正数、负数。此函数从第一个字符
*                        开始转换，遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。
*                        参数str字符串可包含正负号（必须是第一个字符）、小数点。
*     返回值 返回转换后的双精度浮点型数。
*        作 者 武立强
*        时    间    2009-02-05
*        注    意    double 有精度问题
*/
double CharToDouble(const char* str)
{
    assert( NULL != str );
 
    int nFlag = 0; // 是否有小数点存在, 0--不存在,1--存在
 
    int nPositive = 1; //是否是正数, 0---负数, 1---正数
 
    int nLen = 0;
    int nPlace = 0; // 小数点位置
 
    double ldNum = 0;
 
    // 判断第一个字符
 
    if( '+' == *str )
    {
        nPositive = 1;
        str++;
    }
    else if( '-' == *str )
    {
        nPositive = 0;
        str++;
    }
   
    while( '\0' != *str )
    {
        // 检查是否小数点重复
 
        if( '.' == *str && 1 == nFlag )
        {
            break;
        }
        // 检查是存在否小数点
 
        else if( '.' == *str )
        {
            nFlag = 1;
            nPlace = nLen + 1;
        }
        else if( *str > '9' || *str < '0' )
        {
            break;
        }
        else
        {
            // (*str - 48)字符'0'转为数字0
 
            ldNum = ldNum*10 + (*str - 48);
        }
        nLen++;
        str++;
    }
 
    if(nFlag)
    {
        int nTemp = 1;
        for(int i=0; i<(nLen - nPlace); i++)
        {
            nTemp = nTemp * 10;
        }
        ldNum = ldNum / nTemp;
    }
 
    return ((nPositive == 1) ? ldNum : (-ldNum));
}

/*4
*    定义函数 char * IntToChar(char* pDestStr, int nSrcNum);
*    表头文件 #include<assert.h>
*    函数描述    将整型数字转换为字符串,(正负数都可以)，pDestStr 要有足够的空间来
*                        容纳转换后的字符串。
*     返回值     成功:返回转换后的字符串     失败:返回NULL       
*        注    意    时刻注意指针现在指到那里了，malloc() 和free()的个数一定要相同
*                        千万小心内存泄露，和野指针的出现。
*/
char * IntToChar(char* pDestStr, int nSrcNum)
{
    assert( NULL != pDestStr );
   
    int nTemp = 0;    //存储一个位的数字
 
    int nPlace = 0;    //存储小数点的位置
 
    int nNegative = 0;    // 1--负数, 0---非负数
 
    char* pTemp = NULL;
    char* pFirst = NULL;
    int nLen = 0; // 转换后字符串的长度
 
 
    pTemp =(char*)malloc( sizeof(char)*100 );
    if(NULL == pTemp)
    {
        return NULL;
    }
    memset(pTemp, '\0', 100);
    pFirst = pTemp;
 
    // 判断是否是负数
 
    if(nSrcNum < 0)
    {
        nSrcNum = -nSrcNum;
        nNegative = 1;
    }
 
    // 当循环结束后,nTemp 指向字符串的最后!
 
    while( nSrcNum >= 10)
    {
        nTemp = nSrcNum % 10;
        *pTemp = nTemp + 48;    // nTemp + 48 数字转成字符
 
        nSrcNum = nSrcNum / 10; // 两个正数相除,结果取整
 
        pTemp++;
    }
     *pTemp = nSrcNum + 48;
 
    if(nNegative)
    {
        *(++pTemp) = '-';
    }
   
 
    nLen = strlen(pFirst);
    pFirst = pDestStr;
 
    //字符串反转
 
    for(int i=0; i<nLen; i++)
    {
        *pDestStr++ = *pTemp--;
    }
    pTemp++; // 指向字符串开始
 
    *pDestStr = '\0'; // 字符串结束, 切记!
 
 
    // 释放分配在堆上的内存.
 
    free(pTemp);
    pTemp = NULL;
    pDestStr = NULL;
 
    return pFirst;
}

/*5
*    定义函数 char * DoubleToChar(char* pDestStr, double dSrcNum);
*    表头文件 #include<assert.h>
*    函数描述    将浮点型数字转换为字符串,(正负数都可以)，pDestStr 要有足够的空间来
*                        容纳转换后的字符串。double 保存16位有效数字,小数点以后最多15位
*     返回值     成功:返回转换后的字符串     失败:返回NULL
*        注    意    转换后,小数后最后一位,值不确定
*                        时刻注意指针现在指到那里了，malloc() 和free()的个数一定要相同
*                        千万小心内存泄露,和野指针的出现。
*/
char * DoubleToChar(char* pDestStr, double dSrcNum)
{
    assert( NULL != pDestStr );
   
    const double EXPIOSE = 0.0000001;
 
    int nTemp = 0; //存储一个位的数字
 
    int nLen = 0; // 字符串的长度
 
    int nNegative = 0; // 1--负数, 0---非负数
 
    double dPointRight = 0; //小数点后边的数
 
 
    char* pTemp = NULL;
    char* pFirst = NULL;
 
    pTemp =(char*)malloc( sizeof(char)*20 );
    if(NULL == pTemp)
    {
        return NULL;
    }
    memset(pTemp, '\0', 20);
    pFirst = pTemp;
 
    // 判断正负数
 
    if( dSrcNum < 0 )
    {
        nNegative = 1;
        dSrcNum = 0 - dSrcNum;
    }
    dPointRight = dSrcNum - (int)dSrcNum; // 得到小数点后的数据
 
 
    // 整数位处理
 
    while( (int)dSrcNum >= 10 )
    {
        nTemp = (int)dSrcNum % 10;
        *pTemp++ = nTemp + 48;    // nTemp + 48 数字转成字符
 
        dSrcNum = (int)dSrcNum / 10; // 两个正数相除,结果取整
 
    }
  *pTemp++ = (char)(dSrcNum + 48);
    *pTemp = '\0';
    nLen = strlen(pFirst);
    pFirst = pDestStr;
 
    if(nNegative)
    {
        *pDestStr++ = '-';
    }
 
    //字符串反转
 
    pTemp--;
    for(int i=0; i<nLen; i++)
    {
        *pDestStr++ = *pTemp--;
    }
    pTemp++; // 指向字符串开始
 
    free(pTemp);
    pTemp = NULL;
 
    // 小数点处理
 
    *pDestStr++ = '.';
   
    // 小数位处理，double 最多保存小数点后15位.(有效数字是16)
 
    for(i=0; i<16-nLen; i++)
    {
        // double 数据有精度问题,最后一位数的四舍五入问题。
 
        if( (dPointRight >= -EXPIOSE && dPointRight <= EXPIOSE) || (dPointRight-1 >= -EXPIOSE && dPointRight-1 <= EXPIOSE) )
        {
            break;
        }
        *pDestStr++ = (int)(dPointRight*10) + 48;
        dPointRight = (dPointRight*10) - (int)(dPointRight*10); // 得到小数点后的数据
 
    }
   
    // 保证小数点后边至少一个 '0'
 
    if( 0 == i)
    {
        *pDestStr++ = '0';
        *pDestStr = '\0'; // 字符串结束, 切记!
 
    }
    else
    {
        *pDestStr = '\0'; // 字符串结束, 切记!
 
    }
 
    pDestStr = NULL;
    return pFirst;
}

/*6
*    函数原形    int CharToIp(const char* _pchIP);
*    表头文件    #include<assert.h>
*                        #include<string.h>
*                        #include<stdlib.h>
*    函数描述    将字符串形式表示的 IP 转换为一个整数。
*        参 数    _pchIP, 要转换的IP字符串, 格式要严格按照 "192.168.0.1" 格式，
*                        且字符串取值必须在 "0.0.0.0"(最小) 和 "255.255.255.255"(最大)之间。
*     返回值    返回转换后的整数形式。
*/
int CharToIp(const char* _pchIP)
{
    assert( NULL != _pchIP );
   
    char szTemp[4][4];        // 用一个二维数组,分别保存字符串中以点分割的子串
 
    int nLen = strlen(_pchIP);
    int nRow = 0; //行下标
 
    int nCol = 0;    // 列下标
 
 
    for(int i=0; i<nLen; i++)
    {
        if( '.' == _pchIP[i] )
        {
            szTemp[nRow][nCol] = '\0';
            nRow++;
            nCol = 0;
        }
        else
        {
            szTemp[nRow][nCol++] = _pchIP[i];
        }
    }
    szTemp[nRow][nCol] = '\0'; // 别忘了最后的 '\0'
 
 
    return ( (atoi(szTemp[0]) << 24) + (atoi(szTemp[1]) << 16) + (atoi(szTemp[2]) << 8) +atoi(szTemp[3]) );
}

/*7
*    函数原形    char * IpToChar(const int nIP, char * _pchStrIP);
*    表头文件    #include<assert.h>
*                        #include<string.h>
*                        #include<stdlib.h>
*    函数描述    将一个整数转换为一个IP字符串。
*        参 数    nIP,要转换的整数。
*                        _pchStrIP, 存放转换后的IP 字符串。
*     返回值    返回转换后的IP字符串的首地址。
*        备 注   
*/
char * IpToChar(const int nIP, char * _pchStrIP)
{
    assert( NULL != _pchStrIP );
 
    char szTemp[4] = "";
    int nLen = 0;
 
    for(int i=0; i<4 ; i++)
    {
        itoa( ((nIP >> (3-i)*8) & 0x000000FF), szTemp, 10);        // 将十进制整形转换为字符串
 
        strcat(_pchStrIP, szTemp);
        strcat(_pchStrIP, ".");
    }
    nLen = strlen(_pchStrIP);
    _pchStrIP[nLen - 1] = '\0';        // 别忘了 '\0', 将最后一个多余的 '.' 用 '\0' 覆盖
 
   
    return _pchStrIP;
}

/*8
*    函数原形    char * StringFilter(char * pStr, const char ch);
*    表头文件    #include<assert.h>
*    函数描述    字符串过滤，直接修改原串! 将字符串 pStr 中所有的 ch字符过滤掉。
*                        用于对单个字符的过滤，效率很高。
*        参 数    pStr，要过滤的字符串。
*                        ch，要过滤掉的字符。
*     返回值    成功，返回过滤后字符串 pStr 的首地址。
*        备 注    StringFilter(pStr, ' '); ---用于过滤所有空格,很经典!
*/
char * StringFilter(char * pStr, char ch)
{
    assert( NULL != pStr );
   
    char * pStrFirst = pStr;
    int nCount = 0;
 
    // 自己偶尔发现的一个算法,很经典!
 
    while( '\0' != *pStr )
    {
        if( ch == *pStr )
        {
            nCount++;
        }
        else
        {   
            *(pStr - nCount) = *pStr; // 向前移动
 
        }
        pStr++;
    }
 
    *(pStr - nCount) = '\0'; // 别忘了结束
 
 
    return pStrFirst;
}

/*9
*    定义函数 char * StringReplace(char* _pDest, const char* _pSrc, const char* _pKey, const char* _pReplace);
*    表头文件 #include<assert.h>
*    函数描述    字符串替换函数, 在字符串 _pSrc 中查找 _pKey 串,并将其替换成 _pReplace 串, 将结果保存在_pDest中
*                        _pSrc 要查找的原串
*                        _pKey 要查找的关键串
*                        _pReplace 要替换的内容
*                        _pDest 保存处理后的字符串,要有足够的空间来容纳处理后的字符串
*                       
*     返回值     返回 _pDest    的字符串起始地址。
*        注    意    就两种情况,--匹配成功,---匹配失败
*                        StringReplace(strDest, strSrc, " ", ""); ---实现过滤字符串空格的作用
*/
char * StringReplace(char* _pDest, const char* _pSrc, const char* _pKey, const char* _pReplace)
{
    assert( NULL != _pDest && NULL != _pSrc && NULL != _pKey && NULL != _pReplace );
   
    // const char * 不能通过指针改变所指向的字符串的值
 
    const char* pKeyFirst = NULL;
    const char* pFirstFind = NULL; // 标记找到的第一个字符的位置
 
    const char* pLastFind = NULL;    //标记找到的最后一个字符的位置
 
    const char* pReplaceFirst = NULL;
    char* pDestFirst = NULL;
 
    int nFirstFind = 0 ; //第一个字符是否找到, 0--没找到, 1--找到
 
    int nLastFind = 0;    // 最后一个字符
 
   
    pKeyFirst = _pKey;
    pReplaceFirst = _pReplace;
    pDestFirst = _pDest;
 
    while( '\0' != *_pSrc )
    {
        // 逻辑比较部分, 确保完全匹配查找关键串
 
        if( 0 == nFirstFind && *_pSrc == *_pKey )
        {
            nFirstFind = 1;
            pFirstFind = _pSrc;
            _pKey++;
        }
        // 匹配成功
 
        else if( 1 == nFirstFind && *_pSrc == *_pKey && '\0' == *(_pKey+1) )
        {
            nLastFind = 1;
            pLastFind = _pSrc;
            _pKey = pKeyFirst;
        }
        else if( 1 == nFirstFind && *_pSrc == *_pKey )
        {
            _pKey++;
        }   
        // 部分匹配,查找失败,要进行补救----- 将第一个字符移过去,从第二个字符开始从新匹配.
 
        else if( 1 == nFirstFind && *_pSrc != *_pKey )
        {   
            *_pDest++ = *pFirstFind++;
            _pSrc = pFirstFind;
            nFirstFind = 0;
            pFirstFind = NULL;
            _pKey = pKeyFirst;
        }
               
        // 找到,替换为目标串
 
        if( 1 == nFirstFind && 1 == nLastFind )
        {
            while( '\0' != *_pReplace )
            {
                *_pDest++ = *_pReplace++;
            }
 
            nFirstFind = 0;
            nLastFind = 0;
            _pReplace = pReplaceFirst;
            _pKey = pKeyFirst;
        }
        // 没找到
 
        else if( 0 == nFirstFind && 0 == nLastFind )
        {
            *_pDest = *_pSrc;
            _pDest++;
        }
        // 针对一个字符替换为另一个字符的情况
 
        else if( 1 == nFirstFind && '\0' == *(_pKey) )
        {
            while( '\0' != *_pReplace )
            {
                *_pDest++ = *_pReplace++;
            }
 
            nFirstFind = 0;
            nLastFind = 0;
            _pReplace = pReplaceFirst;
            _pKey = pKeyFirst;
        }
        // 最后一次循环了,还没完成---匹配失败
 
        else if( 1 == nFirstFind && 0 == nLastFind && '\0' == *(_pSrc + 1) )
        {
            for(int i=0; i<=(_pSrc - pFirstFind+1); i++ )
            {
                *_pDest++ = *pFirstFind++;
            }
            nFirstFind = 0;
            pFirstFind = NULL;
            _pKey = pKeyFirst;
        }
   
        _pSrc++;
    }
    *_pDest = '\0';
 
    return pDestFirst;
}

/*10
*    定义函数 char * StringFind(char* _pSrc, const char* _pKey);
*    表头文件 #include<assert.h>
*    函数描述    从字符串 _PSrc 中查找 _Pkey, 如果找到,返回第一个找到的地址,
*                        如过没有找到,返回NULL。
*                        _pSrc 要查找的原串
*                        _pKey 要查找的关键串
*     返回值     成功，返回第一个找到的字首地址。没有找到，返回NULL。
*/
char * StringFind(char* _pSrc, const char* _pKey)
{
    assert( NULL != _pSrc && NULL != _pKey );
 
    int nFirstFind = 0 ; //第一个字符是否找到, 0--没找到, 1--找到
 
    int nLastFind = 0;    // 最后一个字符
 
    char* pFirstFind = NULL; // 标记找到的第一个字符的位置
 
    const char* pKeyFirst = _pKey;
 
    while( '\0' != *_pSrc )
    {
        // 逻辑比较部分, 确保完全匹配查找关键串
 
        if( 0 == nFirstFind && *_pSrc == *_pKey )
        {
            nFirstFind = 1;
            pFirstFind = _pSrc;
            _pKey++;
        }
        // 匹配成功
 
        else if( 1 == nFirstFind && *_pSrc == *_pKey && '\0' == *(_pKey+1) )
        {
            return pFirstFind;
        }
        else if( 1 == nFirstFind && *_pSrc == *_pKey )
        {
            _pKey++;
        }   
        // 部分匹配,匹配失败
 
        else if( 1 == nFirstFind && *_pSrc != *_pKey )
        {   
            nFirstFind = 0;
            pFirstFind = NULL;
            _pKey = pKeyFirst;
        }
 
        // 针对一个字符的情况
 
        if( 1 == nFirstFind && '\0' == *(_pKey) )
        {
            return pFirstFind;
        }
        _pSrc++;
    }
 
    return NULL;
}

/*11
*    定义函数 int IsNumberString(const char* _pStr);
*    表头文件 #include<assert.h>
*    函数描述    测试字符串是否是一个数字串
*     返回值     如果是数字串返回0,否则返回-1
*/
int IsNumberString(const char* _pStr)
{
    assert( NULL != _pStr );
    while( '\0' != *_pStr )
    {
        if( *_pStr > '9' || *_pStr < '0' )
        {
            return (-1);
        }
        _pStr++;
    }
    return 0;
}

/*12
*    函数原形 char * StringReverse(char* _pchDest, const char* _pchSrc);
*    表头文件 #include<assert.h>
*    函数描述    将字符串 _pchSrc 到序反转, 结果存放在 _pchDest 中, _pchDest 要有足够的空间
*                        来容纳处理后的字符串
*     返回值     _pchDest 字符串的首地址
*/
char * StringReverse(char* _pchDest, const char* _pchSrc)
{
    assert( NULL != _pchDest && NULL != _pchSrc );
    const char* pSrcFirst = _pchSrc;
    char * pDestFirst = _pchDest;
 
    // 将指针定位到字符串的结尾 '\0' 处
 
    while( '\0' != *_pchSrc++ ) ;
   
    _pchSrc--;
    while( _pchSrc-- >= pSrcFirst )
    {
        *_pchDest++ = *_pchSrc ;
    }
    *(_pchDest-1) = '\0';
 
    return pDestFirst;
}

完