原文地址： 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;
}
完