/*
* 函数原形 char * BinaryToOcatl(char* _pchDest, const char* _pchSrc);
* 表头文件 #include
* #include
* #include
* 函数描述 二进制转八进制。将二进制字符串转换为八进制字符串，_pchSrc 串中不能有 '+'、'-' 和 '.'
* 参 数 _pchSrc，要转换的二进制串，只能是由'0' 和'1' 组成的字符串。
* _pchDest，存放转换后的八进制串。要有足够的空间来容纳处理后的字符串
* 返回值 成功，返回转换后 _pchDest 目标串的首地址
* 失败，返回NULL
* 作 者 武立强
* 时 间 2009-02-17
* 备 注 目前还不支持小数
*/
char * BinaryToOcatl(char* _pchDest, const char* _pchSrc)
{
assert( NULL != _pchDest && NULL != _pchSrc );
char* pchDestFirst = _pchDest;
char* pNewSrc = NULL;
char* pNewSrcFirst = NULL;
char szTemp[4] = "";
int nDestLenth = 0;
int nSrcLenth = 0;
bool bStart = false; // 表示第一个非 '0' 字符的开始
nSrcLenth = strlen(_pchSrc);
// 将_pchSrc 中开头的 '0' 和所有的空格全部过滤掉, 放在一个新串中
pNewSrc = (char*)malloc(sizeof(char) * (nSrcLenth + 1));
pNewSrcFirst = pNewSrc;
memset(pNewSrc, 0, (nSrcLenth + 1));
while( '\0' != *_pchSrc )
{
// 过滤空格
if( ' ' == *_pchSrc )
{
_pchSrc++;
continue;
}
// 判断第一个 非 '0' 字符
if( !bStart && '0' != *_pchSrc )
{
bStart = true;
continue;
}
// 字符串中的字符只能是 '1', '0'
if( bStart && ('1' == *_pchSrc || '0' == *_pchSrc) )
{
*pNewSrc = *_pchSrc;
pNewSrc++;
}
else if ( bStart && !('1' == *_pchSrc || '0' == *_pchSrc) )
{
// _pchSrc 串中有特殊字符,错误!
return NULL;
}
_pchSrc++;
}
_pchSrc = NULL;
// 将 pNewSrc 指针指到字符串的末尾
pNewSrc =pNewSrcFirst + ( strlen(pNewSrcFirst) - 1 );
while( pNewSrc >= pNewSrcFirst )
{
memset(szTemp, 0, 4);
for( int i=2; i>=0; i-- )
{
if( pNewSrc < pNewSrcFirst )
{
szTemp[i] = '0';
}
else
{
szTemp[i] = *pNewSrc;
pNewSrc--;
}
}
// 对比转换
if( !strcmp(szTemp, "000") )
{
*_pchDest = '0';
}
else if( !strcmp(szTemp, "001") )
{
*_pchDest = '1';
}
else if( !strcmp(szTemp, "010") )
{
*_pchDest = '2';
}
else if( !strcmp(szTemp, "011") )
{
*_pchDest = '3';
}
else if( !strcmp(szTemp, "100") )
{
*_pchDest = '4';
}
else if( !strcmp(szTemp, "101") )
{
*_pchDest = '5';
}
else if( !strcmp(szTemp, "110") )
{
*_pchDest = '6';
}
else if( !strcmp(szTemp, "111") )
{
*_pchDest = '7';
}
else
{
// 错误
return NULL;
}
_pchDest++;
}
*_pchDest = '\0';
// 释放内存
free(pNewSrcFirst);
pNewSrcFirst = NULL;
pNewSrc = NULL;
nDestLenth = strlen(pchDestFirst);
// 将 _pchDest 串反转
for( int i=0; i< (nDestLenth/2); i++ )
{
char chTemp = 0;
chTemp = pchDestFirst[i];
pchDestFirst[i] = pchDestFirst[nDestLenth - 1 - i];
pchDestFirst[nDestLenth - 1 - i] = chTemp;
}
return pchDestFirst;
}
/*
* 函数原形 char * BinaryToHex(char* _pchDest, const char* _pchSrc);
* 表头文件 #include
* #include
* #include
* 函数描述 二进制转十六进制。将二进制字符串转换为十六进制字符串，_pchSrc 串中不能有 '+'、'-' 和 '.'
* 参 数 _pchSrc，要转换的二进制串，只能是由'0' 和'1' 组成的字符串。
* _pchDest，存放转换后的十六进制串。要有足够的空间来容纳处理后的字符串
* 返回值 成功，返回转换后 _pchDest 目标串的首地址
* 失败，返回NULL
* 作 者 武立强
* 时 间 2009-02-17
* 备 注 目前还不支持小数
*/
char * BinaryToHex(char* _pchDest, const char* _pchSrc)
{
assert( NULL != _pchDest && NULL != _pchSrc );
char* pchDestFirst = _pchDest;
char* pNewSrc = NULL;
char* pNewSrcFirst = NULL;
char szTemp[5] = "";
int nDestLenth = 0;
int nSrcLenth = 0;
bool bStart = false; // 表示第一个非 '0' 字符的开始
nSrcLenth = strlen(_pchSrc);
// 将_pchSrc 中开头的 '0' 和所有的空格全部过滤掉, 放在一个新串中
pNewSrc = (char*)malloc(sizeof(char) * (nSrcLenth + 1));
pNewSrcFirst = pNewSrc;
memset(pNewSrc, 0, (nSrcLenth + 1));
while( '\0' != *_pchSrc )
{
// 过滤空格
if( ' ' == *_pchSrc )
{
_pchSrc++;
continue;
}
// 判断第一个 非 '0' 字符
if( !bStart && '0' != *_pchSrc )
{
bStart = true;
continue;
}
// 字符串中的字符只能是 '1', '0'
if( bStart && ('1' == *_pchSrc || '0' == *_pchSrc) )
{
*pNewSrc = *_pchSrc;
pNewSrc++;
}
else if ( bStart && !('1' == *_pchSrc || '0' == *_pchSrc) )
{
// _pchSrc 串中有特殊字符,错误!
return NULL;
}
_pchSrc++;
}
_pchSrc = NULL;
// 将 pNewSrc 指针指到字符串的末尾
pNewSrc =pNewSrcFirst + ( strlen(pNewSrcFirst) - 1 );
while( pNewSrc >= pNewSrcFirst )
{
memset(szTemp, 0, sizeof(szTemp));
for( int i=3; i>=0; i-- )
{
if( pNewSrc < pNewSrcFirst )
{
szTemp[i] = '0';
}
else
{
szTemp[i] = *pNewSrc;
pNewSrc--;
}
}
// 对比转换
if( !strcmp(szTemp, "0000") )
{
*_pchDest = '0';
}
else if( !strcmp(szTemp, "0001") )
{
*_pchDest = '1';
}
else if( !strcmp(szTemp, "0010") )
{
*_pchDest = '2';
}
else if( !strcmp(szTemp, "0011") )
{
*_pchDest = '3';
}
else if( !strcmp(szTemp, "0100") )
{
*_pchDest = '4';
}
else if( !strcmp(szTemp, "0101") )
{
*_pchDest = '5';
}
else if( !strcmp(szTemp, "0110") )
{
*_pchDest = '6';
}
else if( !strcmp(szTemp, "0111") )
{
*_pchDest = '7';
}
else if( !strcmp(szTemp, "1000") )
{
*_pchDest = '8';
}
else if( !strcmp(szTemp, "1001") )
{
*_pchDest = '9';
}
else if( !strcmp(szTemp, "1010") )
{
*_pchDest = 'A';
}
else if( !strcmp(szTemp, "1011") )
{
*_pchDest = 'B';
}
else if( !strcmp(szTemp, "1100") )
{
*_pchDest = 'C';
}
else if( !strcmp(szTemp, "1101") )
{
*_pchDest = 'D';
}
else if( !strcmp(szTemp, "1110") )
{
*_pchDest = 'E';
}
else if( !strcmp(szTemp, "1111") )
{
*_pchDest = 'F';
}
else
{
// 错误
return NULL;
}
_pchDest++;
}
*_pchDest = '\0';
// 释放内存
free(pNewSrcFirst);
pNewSrcFirst = NULL;
pNewSrc = NULL;
nDestLenth = strlen(pchDestFirst);
// 将 _pchDest 串反转
for( int i=0; i< (nDestLenth/2); i++ )
{
char chTemp = 0;
chTemp = pchDestFirst[i];
pchDestFirst[i] = pchDestFirst[nDestLenth - 1 - i];
pchDestFirst[nDestLenth - 1 - i] = chTemp;
}
return pchDestFirst;
}
/*
* 函数原形 char * OcatlToBinary(char* _pchDest, const char* _pchSrc);
* 表头文件 #include
* #include
* #include
* 函数描述 八进制转二进制。将八进制字符串转换为二进制字符串，_pchSrc 串中不能有 '+'、'-' 和 '.'
* 参 数 _pchSrc，要转换的八进制串，只能是由'0' 到'7'之间的字符组成的字符串。
* _pchDest，存放转换后的二进制串。要有足够的空间来容纳处理后的字符串
* 返回值 成功，返回转换后 _pchDest 目标串的首地址
* 失败，返回NULL
* 作 者 武立强
* 时 间 2009-02-17
* 备 注 目前还不支持小数
*/
char * OcatlToBinary(char* _pchDest, const char* _pchSrc)
{
assert( NULL != _pchDest && NULL != _pchSrc );
char* pchDestFirst = _pchDest;
char* pNewSrc = NULL;
char* pNewSrcFirst = NULL;
int nSrcLenth = 0;
bool bStart = false; // 表示第一个非 '0' 字符的开始
int nZeroCount = 0; // 表示前边 '0' 的个数
nSrcLenth = strlen(_pchSrc);
pNewSrc = (char*)malloc(sizeof(char) * (nSrcLenth + 1));
pNewSrcFirst = pNewSrc;
memset(pNewSrc, 0, (nSrcLenth + 1));
// 将_pchSrc 中开头的 '0' 和所有的空格全部过滤掉, 放在一个新串pNewSrc中
while( '\0' != *_pchSrc )
{
// 过滤空格
if( ' ' == *_pchSrc )
{
_pchSrc++;
continue;
}
// 判断第一个 非 '0' 字符
if( !bStart && '0' != *_pchSrc )
{
bStart = true;
continue;
}
// 字符串中的字符只能是 '0' 到 '7' 之间的字符
if( bStart && ('0' <= *_pchSrc && '7' >= *_pchSrc) )
{
*pNewSrc = *_pchSrc;
pNewSrc++;
}
else if ( bStart && !('0' <= *_pchSrc && '7' >= *_pchSrc) )
{
// _pchSrc 串中有特殊字符,错误!
return NULL;
}
_pchSrc++;
}
_pchSrc = NULL;
pNewSrc = pNewSrcFirst;
// 逻辑转换
while( '\0' != *pNewSrc )
{
if( '0' == *pNewSrc )
{
strcat(_pchDest, "000");
}
else if( '1' == *pNewSrc )
{
strcat(_pchDest, "001");
}
else if( '2' == *pNewSrc )
{
strcat(_pchDest, "010");
}
else if( '3' == *pNewSrc )
{
strcat(_pchDest, "011");
}
else if( '4' == *pNewSrc )
{
strcat(_pchDest, "100");
}
else if( '5' == *pNewSrc )
{
strcat(_pchDest, "101");
}
else if( '6' == *pNewSrc )
{
strcat(_pchDest, "110");
}
else if( '7' == *pNewSrc )
{
strcat(_pchDest, "111");
}
else
{
// 错误
return NULL;
}
_pchDest += 3;
pNewSrc++;
}
// 释放内存
free(pNewSrcFirst);
pNewSrcFirst = NULL;
pNewSrc = NULL;
nZeroCount = 0; //使用前清零
bStart = false;
_pchDest = pchDestFirst;
// 将 _pchDest 最前边开始的 '0' 过滤掉
while( '\0' != *_pchDest )
{
// 找到第一个非 '0' 字符
if( !bStart && '0' != *_pchDest )
{
nZeroCount = (_pchDest - pchDestFirst); // 得到前边0的个数
bStart = true;
}
if( bStart )
{
*(_pchDest - nZeroCount) = *_pchDest; // 向前移动
}
_pchDest++;
}
*(_pchDest - nZeroCount) = '\0'; //别忘了 '\0'
return pchDestFirst;
}
/*
* 函数原形 char * HexToBinary(char* _pchDest, const char* _pchSrc);
* 表头文件 #include
* #include
* #include
* 函数描述 十六进制转二进制。将十六进制字符串转换为二进制字符串，_pchSrc 串中不能有 '+'、'-' 和 '.'
* 参 数 _pchSrc，要转换的十六进制串，只能是由'0' 到'7'和 'A'到 'F'之间的字符组成的字符串。
* _pchDest，存放转换后的二进制串。要有足够的空间来容纳处理后的字符串
* 返回值 成功，返回转换后 _pchDest 目标串的首地址
* 失败，返回NULL
* 作 者 武立强
* 时 间 2009-02-17
* 备 注 目前还不支持小数
*/
char * HexToBinary(char* _pchDest, const char* _pchSrc)
{
assert( NULL != _pchDest && NULL != _pchSrc );
char* pchDestFirst = _pchDest;
char* pNewSrc = NULL;
char* pNewSrcFirst = NULL;
int nSrcLenth = 0;
bool bStart = false; // 表示第一个非 '0' 字符的开始
int nZeroCount = 0; // 表示前边 '0' 的个数
nSrcLenth = strlen(_pchSrc);
pNewSrc = (char*)malloc(sizeof(char) * (nSrcLenth + 1));
pNewSrcFirst = pNewSrc;
memset(pNewSrc, 0, (nSrcLenth + 1));
// 将_pchSrc 中开头的 '0' 和所有的空格全部过滤掉, 放在一个新串pNewSrc中
while( '\0' != *_pchSrc )
{
// 过滤空格
if( ' ' == *_pchSrc )
{
_pchSrc++;
continue;
}
// 判断第一个 非 '0' 字符
if( !bStart && '0' != *_pchSrc )
{
bStart = true;
continue;
}
// 字符串中的字符只能是 '0' 到 '9' 和 'A'到 'F' 之间的字符
if( bStart && (('0' <= *_pchSrc && '7' >= *_pchSrc) || ('A' <= *_pchSrc && 'F' >= *_pchSrc)) )
{
*pNewSrc = *_pchSrc;
pNewSrc++;
}
else if ( bStart && !(('0' <= *_pchSrc && '7' >= *_pchSrc) || ('A' <= *_pchSrc && 'F' >= *_pchSrc)) )
{
// _pchSrc 串中有特殊字符,错误!
return NULL;
}
_pchSrc++;
}
_pchSrc = NULL;
pNewSrc = pNewSrcFirst;
// 逻辑转换
while( '\0' != *pNewSrc )
{
if( '0' == *pNewSrc )
{
strcat(_pchDest, "0000");
}
else if( '1' == *pNewSrc )
{
strcat(_pchDest, "0001");
}
else if( '2' == *pNewSrc )
{
strcat(_pchDest, "0010");
}
else if( '3' == *pNewSrc )
{
strcat(_pchDest, "0011");
}
else if( '4' == *pNewSrc )
{
strcat(_pchDest, "0100");
}
else if( '5' == *pNewSrc )
{
strcat(_pchDest, "0101");
}
else if( '6' == *pNewSrc )
{
strcat(_pchDest, "0110");
}
else if( '7' == *pNewSrc )
{
strcat(_pchDest, "0111");
}
else if( '8' == *pNewSrc )
{
strcat(_pchDest, "1000");
}
else if( '9' == *pNewSrc )
{
strcat(_pchDest, "1001");
}
else if( 'A' == *pNewSrc )
{
strcat(_pchDest, "1010");
}
else if( 'B' == *pNewSrc )
{
strcat(_pchDest, "1011");
}
else if( 'C' == *pNewSrc )
{
strcat(_pchDest, "1100");
}
else if( 'D' == *pNewSrc )
{
strcat(_pchDest, "1101");
}
else if( 'E' == *pNewSrc )
{
strcat(_pchDest, "1110");
}
else if( 'F' == *pNewSrc )
{
strcat(_pchDest, "1111");
}
else
{
// 错误
return NULL;
}
_pchDest += 4;
pNewSrc++;
}
// 释放内存
free(pNewSrcFirst);
pNewSrcFirst = NULL;
pNewSrc = NULL;
nZeroCount = 0; //使用前清零
bStart = false;
_pchDest = pchDestFirst;
// 将 _pchDest 最前边开始的 '0' 过滤掉
while( '\0' != *_pchDest )
{
// 找到第一个非 '0' 字符
if( !bStart && '0' != *_pchDest )
{
nZeroCount = (_pchDest - pchDestFirst); // 得到前边0的个数
bStart = true;
}
if( bStart )
{
*(_pchDest - nZeroCount) = *_pchDest; // 向前移动
}
_pchDest++;
}
*(_pchDest - nZeroCount) = '\0'; //别忘了 '\0'
return pchDestFirst;
}
/*
* 函数原形 int BinaryStringToInt(const char* _pStr);
* 表头文件 #include
* 函数描述 二进制字符串转换为整形数字。_pStr 串中不能有 '+'、'-' 和 '.'
* 参 数 _pStr，要转换的二进制串，只能是由'0'和 '1'字符组成的字符串。
* 返回值 成功，返回转换后的整数
* 失败，返回-1
* 作 者 武立强
* 时 间 2009-02-17
* 备 注 _pStr 字符串中的空格可以被过滤掉,_pStr中可以存在空格, 当您传入"" 或 " " 时，
* 函数将返回 0
*/
int BinaryStringToInt(const char* _pStr)
{
assert( NULL != _pStr );
int nNumber = 0;
while( '\0' != *_pStr )
{
if( ' ' == *_pStr )
{
// 过滤空格字符
}
else if( *_pStr < '0' || *_pStr > '1')
{
// 如果遇到非'0'--'1' 之间的字符,直接返回 -1
return -1;
}
else
{
nNumber = nNumber*2 + (*_pStr -48);
}
_pStr++;
}
return nNumber;
}
/*
* 函数原形 char * IntToBinaryString(char* _pchBinStr, int nNumber);
* 表头文件 #include
* 函数描述 将整数转换为二进制字符串，只支持正数转换, 不支持负数和 0 的转换
* 参 数 nNumber，要转换的正整数
* _pchBinStr 存放转换后的二进制字符串。要有足够的空间来容纳转换后的字符串
* 返回值 成功，返回转换后的二进制字符串
* 失败，返回NULL
* 作 者 武立强
* 时 间 2009-02-18
* 备 注 目前还不支持小数
*/
char * IntToBinaryString(char* _pchBinStr, int nNumber)
{
assert( NULL != _pchBinStr );
char * pchFirst = _pchBinStr;
if( nNumber <= 0 )
{
return NULL;
}
while( nNumber > 0 )
{
*_pchBinStr = (nNumber % 2) + 48; // +48 是将数字转换为字符, '0'=48
nNumber = nNumber / 2; // 两个整数相除,结果取整
_pchBinStr++;
}
*_pchBinStr = '\0';
int nLen = 0;
nLen = _pchBinStr - pchFirst; //转换后字符串的长度
// 将字符串反转(记住此算法)
for(int i=0; i<(nLen/2); i++)
{
char chTemp = 0; // 每次都初始化为 0
chTemp = pchFirst[i];
pchFirst[i] = pchFirst[nLen - 1 - i];
pchFirst[nLen - 1 - i] = chTemp;
}
return pchFirst;
} |
