/*
* 计算字符串的长度
*/
int strlen(const char* str)
{
assert( str != NULL);
int len = 0;
while( *str++ != '\0')
{
len++;
}
return len;
}
/*
* 字符串复制函数
*/
char * strcpy(char* strDest, const char* strSrc)
{
assert( (strDest != NULL) && (strSrc != NULL) );
char* address = strDest; //保存首地址
while( (*strDest++ = *strSrc++) != '\0' )
{
; // do nothing
}
return address;
}
/*
* 定义函数 char * ConversionString(char* _pDest, const char * _pSrc, int _nFlag);
* 表头文件 #include
* 函数描述 字符串大小写转换函数。
* 此函数从第一个字符开始转换，遇到字符串结束时('\0')才结束转换。
* _pSrc 要转换的字符串首地址
* _pDest 转换后的字符串首地址, _pDest要有足够的空间来容纳转换后的字符串
_nFlag = 0, 大写转小写，小写转大写，其他字符不变
_nFlag = 1, 全部转换为小写，其他字符不变
_nFlag = 2 , 全部转换为大写，其他字符不变
_nFlag 取其他值是，函数返回 NULL
* 返回值 成功，返回 _pDest 的字符串起始地址。错误，返回NULL
* 作 者 武立强
* 时 间 2009-02-05
*/
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;
}
/*
* 函数原形 int CharToInt(const char* _pStr);
* 表头文件 #include
* 函数描述 将字符串转换为整数，_pStr串中不能有 '+'、'-' 和 '.'，不支持小数和负数，
* 此函数从第一个字符开始转换，遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。
* 参 数 _pStr，要转换为整数的字符串，只能是由'0' 到'9'之间的字符组成的字符串。
* 返回值 成功，返回转换后的整数。
* 失败，返回 -1
* 作 者 武立强
* 时 间 2009-02-18
* 备 注 _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;
}
/*
* 定义函数 double CharToDouble(const char* str);
* 表头文件 #include
* 函数描述 将字符串转换成数字，支持整数、小数、正数、负数。此函数从第一个字符
* 开始转换，遇到非数字或字符串结束时('\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));
}
/*
* 用一个函数给数组赋值
*/
void Input(int a[], int length)
{
for(int i=0; i<length; i++)
{
scanf("%d", &a[i]);
}
}
/*
* 定义函数 char * IntToChar(char* pDestStr, int nSrcNum);
* 表头文件 #include
* 函数描述 将整型数字转换为字符串,(正负数都可以)，pDestStr 要有足够的空间来
* 容纳转换后的字符串。
* 返回值 成功:返回转换后的字符串 失败:返回NULL
* 作 者 武立强
* 时 间 2009-02-06
* 注 意 时刻注意指针现在指到那里了，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;
}
/*
* 定义函数 char * DoubleToChar(char* pDestStr, double dSrcNum);
* 表头文件 #include
* 函数描述 将浮点型数字转换为字符串,(正负数都可以)，pDestStr 要有足够的空间来
* 容纳转换后的字符串。double 保存16位有效数字,小数点以后最多15位
* 返回值 成功:返回转换后的字符串 失败:返回NULL
* 作 者 武立强
* 时 间 2009-02-07
* 注 意 转换后,小数后最后一位,值不确定
* 时刻注意指针现在指到那里了，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;
}
/*
* 函数原形 int CharToIp(const char* _pchIP);
* 表头文件 #include
* #include
* #include
* 函数描述 将字符串形式表示的 IP 转换为一个整数。
* 参 数 _pchIP, 要转换的IP字符串, 格式要严格按照 "192.168.0.1" 格式，
* 且字符串取值必须在 "0.0.0.0"(最小) 和 "255.255.255.255"(最大)之间。
* 返回值 返回转换后的整数形式。
* 作 者 武立强
* 时 间 2009-02-20
* 备 注
*/
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]) );
}
/*
* 函数原形 char * IpToChar(const int nIP, char * _pchStrIP);
* 表头文件 #include
* #include
* #include
* 函数描述 将一个整数转换为一个IP字符串。
* 参 数 nIP,要转换的整数。
* _pchStrIP, 存放转换后的IP 字符串。
* 返回值 返回转换后的IP字符串的首地址。
* 作 者 武立强
* 时 间 2009-02-20
* 备 注
*/
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;
}
/*
* 定义函数 char * GetPassword(char* _pPassword, int _nLen, char _chShow);
* 表头文件 #include
* #include
* 函数描述 密码读取函数，从终端度取密码。
* _pPassword 要有足够的空间来容纳读取的密码。
* _nLen 限制密码的最大长度
* _chShow 为输入密码后回显的字符。值为 0 时不回显。
* 返回值 返回 _pPassword 的字符串起始地址。
* 作 者 武立强
* 时 间 2009-02-08
* 注 意 \b Backspace \n Newline \r Carriage return
* getch() 读取一个字符,不回显.
* 特殊字符还没有被过滤掉！
*/
char * GetPassword(char* _pPassword, int _nLen, char _chShow)
{
assert( NULL != _pPassword );
int nCourrent = 0;
char * pFirst = _pPassword;
while(1)
{
*_pPassword = getch();
if( '\n' == *_pPassword || '\r' == *_pPassword )
{
*_pPassword = '\0';
break;
}
else if( '\b' == *_pPassword && 0 == nCourrent )
{
continue;
}
else if( '\b' == *_pPassword && 0 == _chShow )
{
_pPassword--;
nCourrent--;
continue;
}
else if( '\b' == *_pPassword )
{
_pPassword--;
nCourrent--;
printf("\b \b"); // 注意细节,中间有个空格
continue;
}
else if( nCourrent >= _nLen )
{
continue;
}
// 是否回显
if( 0 != _chShow )
{
printf("%c", _chShow);
}
_pPassword++;
nCourrent++;
}
_pPassword = NULL;
return pFirst;
} |
