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;
}
完