linux函数怎么封装,常用的工具函数封装（4）

最新推荐文章于 2021-05-13 15:12:06 发布

weixin_39927059

最新推荐文章于 2021-05-13 15:12:06 发布

阅读量150

点赞数 1

文章标签： linux函数怎么封装

* 函数原形 int FileCopy(const char* pDestFileName, const char* pSrcFileName);

* 表头文件 #include* 函数描述复制文件函数。将 pSrcFileName 文件复制到 pDestFileName 处，

* 如果 pDestFileName 文件存在，将回覆盖此文件。

* 参数 pSrcFileName，要复制的源文件名

* pDestFileName, 源文件复制后的文件，如果系统中存在此名称的文件，将会覆盖掉！

* 返回值成功，返回 1

* 失败，返回 0

* 作者武立强

* 时间 2009-02-19

* 备注在复制前要先判断目标文件是否存在，否则会覆盖掉已经存在的文件

int FileCopy(const char* pDestFileName, const char* pSrcFileName)

{

assert( NULL != pDestFileName && NULL != pSrcFileName );

FILE *fpDest = NULL;

FILE *fpSrc = NULL;

// 打开源文件, 只读

fpSrc = fopen(pSrcFileName, "rb");

if( NULL == fpSrc )

{

// 打开文件失败

return 0;

}

// 打开目的文件,只写

fpDest = fopen(pDestFileName, "wb");

if( NULL == fpDest )

{

// 打开文件失败

fclose(fpSrc);

return 0;

}

while( !feof(fpSrc) )

{

int nCount = 0; // 读取字节的个数

char szBuf[500] = "";

// 一次读写500个字节,效率还可以！

nCount = fread(szBuf, sizeof(char), 500, fpSrc);

fwrite(szBuf, sizeof(char), nCount, fpDest);

}

fclose(fpDest);

fclose(fpSrc);

return 1;

}

* 函数原形 int CheckFileIsEmpty(const char* _pchFileName);

* 表头文件 #include* 函数描述检查一个文件是否为空文件

* 参数 _pchFileName, 文件名字符串

* 返回值 1，表示文件是空文件

* 0，表示文件非空

* -1，函数执行失败(打开文件失败)

* 作者武立强

* 时间 2009-02-19

* 备注

int CheckFileIsEmpty(const char* _pchFileName)

{

assert( NULL != _pchFileName );

char chTemp = 0;

int nRead = 0;

FILE * fp = NULL;

// 打开文件，只读

fp = fopen(_pchFileName, "rb");

if( NULL == fp )

{

return -1;

}

// 读一个字节

nRead = fread(&chTemp, sizeof(char), 1, fp);

if( 1 == nRead )

{

return 1;

}

else

{

return 0;

}

// 关闭文件

fclose(fp);

}

* 函数原形 int CheckIsFileExist(const char* _pchFileName);

* 表头文件 #include* 函数描述检查文件是否存在。

* 参数 _pchFileName, 文件路径名

* 返回值 1，文件存在

* 0，文件不存在

* 作者武立强

* 时间 2009-02-19

* 备注

int CheckIsFileExist(const char* _pchFileName)

{

assert( NULL != _pchFileName );

FILE * fp = NULL;

fp = fopen(_pchFileName, "r");

if( NULL == fp)

{

return 0;

}

else

{

return 1;

}

fclose(fp);

}

* 函数原形 int CheckIsLegalUser(const char* _pchFileName, const struct stUserInfo* _pstUserInfo);

* 表头文件 #include* #include* 函数描述用户登陆验证，校验用户信息的合法性。此函数主要用于用户登陆时用户名，密码的验证。将 _pstUserInfo 中的

* 用户名，密码，和密码文件_pchFileName中存储的用户信息进行比较。

* 参数 _pchFileName，存储用户名、密码的文件，此文件中，每一个用户信息 (用户名，密码)占一行，

* 且用户名和密码用 Tab 键分割.

* stUserInfo，用户信息结构体。定义如下：

* struct stUserInfo

* {

* char szUserName[21];

* char szPassword[21];

* };

* 返回值成功，合法用户返回 0, 非法用户返回 1

* 失败，返回 -1

* 作者武立强

* 时间 2009-02-20

* 备注

int CheckIsLegalUser(const char* _pchFileName, const struct stUserInfo* _pstUserInfo)

{

assert( NULL != _pstUserInfo && NULL != _pchFileName );

FILE * fp = NULL;

fp = fopen(_pchFileName, "r");

if( NULL == fp )

{

printf("Open %s file error : CheckIsLegalUser \n", _pchFileName);

return (-1);

}

while( !feof(fp) )

{

char szName[21] = "";

char szPassword[21] = "";

fscanf(fp, "%s%s", szName, szPassword);

if( !strcmp(_pstUserInfo->szUserName, szName) && !strcmp(_pstUserInfo->szPassword, szPassword) )

{

// 用户名密码和密码文件中一致

return 0;

}

fclose(fp);

return 1;

}

* 函数原形 int WriteLogToFile(const char* _pchFileName, const char* _pchLogStr);

* 表头文件 #include* 函数描述将日志字符串写到文件中

* 参数 _pchFileName，日志文件名

* _pchLogStr，具有一定格式的日志字符串

* 返回值成功，返回 0

* 失败，返回 -1

* 作者武立强

* 时间 2009-02-20

* 备注需要自己组织一个具有一定格式的日志字符串

int WriteLogToFile(const char* _pchFileName, const char* _pchLogStr)

{

assert( NULL != _pchFileName && NULL != _pchLogStr );

FILE * fp = NULL;

// 打开文件, 追加的方式

fp = fopen(_pchFileName, "a");

if( NULL == fp )

{

printf("open %s error:WriteLogToFile \n", _pchFileName);

return (-1);

}

// 写文件

fprintf(fp, "%s\n", _pchLogStr);

fclose(fp);

return 0;

}

* 函数原形 char * GetCurrentTimeString(char* _pchTimeStr);

* 表头文件 #include* #include* #include* 函数描述当前系统时间转换为字符串格式。生成的字符串格式为："2009-2-21 9:39:29"(18个字符)

* 参数 _pchTimeStr，存放转换后的字符串。要有足够的空间来存放转换后的字符串

* 返回值返回_pchTimeStr首地址。

* 作者武立强

* 时间 2009-02-21

* 备注使用前要将_pchTimeStr所指向的内容全部清零(必须清零,要不会出错)

char * GetCurrentTimeString(char* _pchTimeStr)

{

assert( NULL != _pchTimeStr );

time_t timep = 0;

struct tm *p = NULL;

char szTemp[5] = "";

time(&timep);

p=localtime(&timep); /*取得当地时间*/

// 年

strcat(_pchTimeStr, itoa(1900 + p->tm_year, szTemp, 10) );

strcat(_pchTimeStr, "-");

// 月

strcat(_pchTimeStr, itoa(1 + p->tm_mon, szTemp, 10) );

strcat(_pchTimeStr, "-");

// 日

strcat(_pchTimeStr, itoa(p->tm_mday, szTemp, 10) );

strcat(_pchTimeStr, " ");

// 时

strcat(_pchTimeStr, itoa(p->tm_hour, szTemp, 10) );

strcat(_pchTimeStr, ":");

// 分

strcat(_pchTimeStr, itoa(p->tm_min, szTemp, 10) );span style=fclosecolor: rgb(255, 0, 0);color: rgb(255, 0, 0);;color: rgb(0, 0, 204);

color: rgb(255, 0, 255);

color: rgb(0, 0, 204);

strcat(_pchTimeStr, ":");

// 秒

strcat(_pchTimeStr, itoa(p->tm_sec, szTemp, 10) );

return _pchTimeStr;

}

* 函数原形 int GetCurrentTimeOneElements(const int nFlag);

* 表头文件 #include* #include* #include* 函数描述得到当前系统时间的一个基本元素。例如，年、月、日、时、分、秒、星期

* 参数 nFlag，表示位，只能是 0 -6 之间的正整数。

* 返回值 nFlag = 0，返回当前年

* nFlag = 1，返回当前月(1-12)

* nFlag = 2，返回当前日(1-31)

* nFlag = 3，返回当前时(0-23)

* nFlag = 4，返回当前分(0-59)

* nFlag = 5，返回当前秒(0-59)

* nFlag = 6，返回当前星期(1-7)

* 当nFlag为其他值是，返回 -1

* 作者武立强

* 时间 2009-02-21

* 备注

int GetCurrentTimeOneElements(const int nFlag)

{

if( nFlag < 0 || nFlag > 6)

{

return (-1);

}

time_t timep = 0;

struct tm *p = NULL;

const int arrWeekDay[7] = {7,1,2,3,4,5,6};

time(&timep);

p=localtime(&timep); /*取得当地时间*/

switch( nFlag )

{

case 0:

// 以整数形式返回年份

return (1900 + p->tm_year);

break;

case 1:

// 月

return (1 + p->tm_mon);

break;

case 2:

// 日

return (p->tm_mday);

break;

case 3:

// 时

return (p->tm_hour);

break;

case 4:

// 分

return (p->tm_min);

break;

case 5:

// 秒

return (p->tm_sec);

break;

case 6:

// 星期

return ( arrWeekDay[p->tm_wday] );

break;

default:

return (-1);

}

return (-1);

}

* 函数原形 char * IniFileAnalyse(const char* _pchFileName, const char* _pchArea, const char* _pchKey, char* _pchValue);

* 表头文件 #include* #include* 函数描述固定格式的文件解析。文件建议.ini 后缀，当然也可以是其他的文件,文件的格式

* 要求如下：example.ini

* [login] // [域名]

* name=admin // key = value

* password=888888

* ...

* 文件可以有多个域，但不能有重名的域。

* 每一行可以有空格,

* 每一行长度不能超过500个字符

* 参数 _pchFileName, 文件名

* _pchArea，域名

* _pchKey，要查找的关键字

* _pchValue，存放找到的结果，要有足够的空间来存放找到的结果!

* 返回值如果查找成功，返回第一个找到_pchKey所对应的_pchValue串的首地址

* 没有找到后函数调用失败都返回 NULL

* 作者武立强

* 时间 2009-02-22

* 备注用到了StringFilter()函数。

char * IniFileAnalyse(const char* _pchFileName, const char* _pchArea, const char* _pchKey, char* _pchValue)

{

assert( NULL != _pchFileName && NULL != _pchArea && NULL != _pchKey && NULL != _pchValue );

FILE * fp = NULL;

char szTemp[501] = ""; // 支持文件一行最多500个字符

int nKeyLength = strlen(_pchKey);

// 打开文件,只读

fp = fopen(_pchFileName, "r");

if( NULL == fp )

{

printf("IniFileAnalyse: open %s file error!\n");

return NULL;

}

while( !feof(fp) )

{

// 读取一行数据, 将最后的那个 '\n' 也读进来了!

fgets(szTemp, sizeof(szTemp), fp);

StringFilter(szTemp, ' '); // 过滤所有空格

StringFilter(szTemp, '\n'); // 过滤 '\n'

if( '[' == szTemp[0] )

{

// 找到一个域的开始

// 将 '[' 和 ']' 分别过滤掉

StringFilter(szTemp, '[');

StringFilter(szTemp, ']');

}

else

{

continue;

}

if( !strcmp(szTemp, _pchArea) )

{

// 找到一个域

;

}

else

{

continue;

}

while( !feof(fp) )

{

fgets(szTemp, sizeof(szTemp), fp);

StringFilter(szTemp, ' '); // 过滤所有空格

if( '[' == szTemp[0] )

{

// 已经到了下一个域了,还没有找到,直接返回

fclose(fp);

return NULL;

}

// 比较前 nKeyLength 个是否相等

else if( !strncmp(szTemp, _pchKey, nKeyLength) )

{

// 找到了_pchKey相同的字符串

StringFilter(szTemp, '\n'); // 过滤最后的那个 '\n'

strcpy(_pchValue, (szTemp + nKeyLength + 1));

fclose(fp);

return _pchValue;

}

fclose(fp);

return NULL;

}

* 函数原形 char * StringMove(char* _pchDest, const char* _pchSrc, int nNumber);

* 表头文件 #include* #include* 函数描述字符串循环移动。将字符串循环向左或向右移动 nNumber 个字符。

* 参数 _pchSrc，要移动的原串

* nNumber，移动的位数，当 nNumber > 0 时，向左移动， nNumber < 0时，向右移动

* _pchKey，要查找的关键字

* _pchDest，存放移动后的字符串，要有足够的空间来存放处理后的字符串。

* 返回值返回 _pchDest 字符串的首地址。

* 作者武立强

* 时间 2009-02-22

* 备注此函数可用于简单的加密和解密运算。

char * StringMove(char* _pchDest, const char* _pchSrc, int nNumber)

{

assert( NULL != _pchDest && NULL != _pchSrc);

int nSrcLen = strlen(_pchSrc);

if( nNumber >= 0 )

{

// 向左移动

nNumber = nNumber % nSrcLen; // 处理移动的位数大于字符串长度时的情况

strcpy(_pchDest, _pchSrc + nNumber);

strncat(_pchDest, _pchSrc, nNumber);

}

else

{

//向右移动

nNumber = (0 - nNumber);

nNumber = nNumber % nSrcLen;

strcpy(_pchDest, _pchSrc + (nSrcLen - nNumber));

strncat(_pchDest, _pchSrc, nSrcLen - nNumber);

}

return _pchDest;

}

* 函数原形 void StringExclusiveEncription(char* _pchSrc, int _nLen, char _chKey);

* 表头文件 #include* #include* 函数描述异或运算加密函数,直接修改原串。

* 将一个字符串的每一个字符和一个特定的字符异或运算

* 第一次异或----加密

* 第二次异或----解密

* 参数 _pchSrc，要加密的原串

* _nLen, 原串的长度，用 strlen() 函数可以得到。

* _chKey，加密的密钥

* 返回值无返回值

* 作者武立强

* 时间 2009-02-22

* 备注 Exclusive:异或。Encription:加密

void StringExclusiveEncription(char* _pchSrc, int _nLen, char _chKey)

{

assert( NULL != _pchSrc );

for(int i=0; i<_nlen i>

{

_pchSrc[i] = _pchSrc[i] ^ _chKey; // 异或运算

}

return ;

}

* 函数原形 void StringInverseEncription(char* _pchSrc, int _nLen);

* 表头文件 #include* #include* 函数描述取反运算加密函数,直接修改原串。

* 将一个字符串的每一个字符取反

* 第一次取反----加密

* 第二次取反----解密

* 参数 _pchSrc，要加密的原串

* _nLen, 原串的长度，用 strlen() 函数可以得到。

* 返回值无返回值

* 作者武立强

* 时间 2009-02-22

* 备注 Inverse:相反的。Encription:加密

void StringInverseEncription(char* _pchSrc, int _nLen)

{

assert( NULL != _pchSrc );

for(int i=0; i<_nlen i>

{

_pchSrc[i] = ~_pchSrc[i]; // 取反运算

}

return ;

}

* 函数原形 int GetMaxNumber(int _nArr[], int _nLen);

* 表头文件 #include* 函数描述得到一个数组中最大的数 (冒泡法)

* 参数 _nArr，数组名

* _nLen, 数组的长度

* 返回值数组中最大的数

* 作者武立强

* 时间 2009-02-22

* 备注

int GetMaxNumber(int _nArr[], int _nLen)

{

assert( NULL != _nArr );

int nTemp = _nArr[0];

for(int i=0; i<_nlen i>

{

if( nTemp < _nArr[i] )

{

nTemp = _nArr[i];

}

return nTemp;

}

* 函数原形 int GetMaxNumber(int _nArr[], int _nLen);

* 表头文件 #include* 函数描述得到一个数组中第二大的数 (冒泡法)

* 参数 _nArr，数组名

* _nLen, 数组的长度

* 返回值数组中最大的数

* 作者武立强

* 时间 2009-02-22

* 备注

int GetSecondMaxNumber(int _nArr[], int _nLen)

{

assert( NULL != _nArr );

int nFirst = _nArr[0];

int nSecond = _nArr[0];

// 得到最大的数

for(int i=0; i<_nlen i>

{

if( nFirst < _nArr[i] )

{

nFirst = _nArr[i];

}

// 得到第二大的数

for(i=0; i<_nlen i>

{

if( nSecond < _nArr[i] && _nArr[i] != nFirst )

{

nSecond = _nArr[i];

}

return nSecond;

}

* 函数原形 char * GetSubString(char * _pchSubStr, const char* _pchStr, int _nStart, int _nEnd);

* 表头文件 #include* #include* 函数描述得到一个字符串中的子串

* 参数 _pchStr，原字符串

* _nStart, 原字符串开始下标

* _nEnd，原字符串结束下标

* _pchSubStr，存放找到的子串，要有足够的空间来存放处理后的子串。

* 返回值 _pchSubStr子串的首地址。

* 作者武立强

* 时间 2009-02-22

* 备注

char * GetSubString(char * _pchSubStr, const char* _pchStr, int _nStart, int _nEnd)

{

assert( NULL != _pchSubStr && NULL != _pchStr );

int nSrcLen = strlen(_pchStr);

char* _pchFirst = _pchSubStr;

// 逻辑判断, 是否超出原串的范围

if( _nStart < 0 || _nEnd < 0 )

{

return NULL;

}

else if( _nStart >= nSrcLen || _nEnd >= nSrcLen )

{

return NULL;

}

else if( _nStart > _nEnd )

{

return NULL;

}

for(int i=0; i

{

*_pchSubStr++ = *(_pchStr++ + _nStart);

}

*_pchSubStr = '\0';

return _pchFirst;

}

* 函数原形 char * MuitCharFilterToOne(char* _pchStr, char _chKey);

* 表头文件 #include* 函数描述直接修改原串，将字符串_pchStr中的多个chKey过滤成一个

* 参数 _pchStr，原字符串

* _chKey，要过滤的字符

* 返回值 _pchStr串的首地址。

* 作者武立强

* 时间 2009-02-22

* 备注 MuitCharFilterToOne(str, char ' '); 将多个空格过滤成一个

char * MuitCharFilterToOne(char* _pchStr, char _chKey)

{

assert( NULL != _pchStr);

char* pchFirst = _pchStr;

int nCount = 0;

int nFind = 0;

while( '\0' != *_pchStr )

{

if( 0 == nFind && _chKey == *_pchStr )

{

nFind = 1;

*(_pchStr - nCount) = *_pchStr; // 向前移动

}

else if( 1 == nFind && _chKey == *_pchStr )

{

nCount++;

}

else

{

nFind = 0;

*(_pchStr - nCount) = *_pchStr; // 向前移动

}

_pchStr++;

}

*(_pchStr - nCount) = '\0';

return pchFirst;

}

* 函数原形 char * GetKeyStr(char* _pStr);

* 表头文件 #include * #include * #include * 函数描述得到键盘的字符串值

* 参数 _pStr，存放生成的字符串

* 返回值 _pStr串的首地址。

* 作者武立强

* 时间 2009-04-03

* 备注

char * GetKeyStr(char* _pStr)

{

assert(NULL != _pStr);

char ch = getch();

if( ch < 0 )

{

ch = getch();

if( 72 == ch )

{

strcpy(_pStr, "up");

}

else if( 80 == ch )

{

strcpy(_pStr, "down");

}

else if( 75 == ch )

{

strcpy(_pStr, "left");

}

else if( 77 == ch )

{

strcpy(_pStr, "right");

}

else if( 13 == ch )

{

strcpy(_pStr, "enter");

}

else if( 27 == ch )

{

strcpy(_pStr, "esc");

}

else if( 9 == ch )

{

strcpy(_pStr, "tab");

}

else if( 8 == ch )

{

strcpy(_pStr, "backspace");

}

else if( 32 == ch )

{

strcpy(_pStr, "space");

}

else

{

_pStr[0] = ch;

_pStr[1] = '\0';

}

return _pStr;

}

* 函数原形 void * memmove(void* _pDest, const void* _pSrc, int _nCount);

* 表头文件 #include * 函数描述内存移动函数,将内存中的内容从一个地方移动到另一个地方

* 参数 _pSrc，源内存首地址

* _pDest,目的内存首地址

* 返回值目的内存首地址

* 作者武立强

* 时间 2009-04-08

* 备注

void * memmove(void* _pDest, const void* _pSrc, int _nCount)

{

assert( _pDest && NULL != _pSrc);

char* pDest = (char*)_pDest;

char* pSrc = (char*)_pSrc;

for(int i=0; i<_ncount color: rgb nsrclen ncountbrtabspan style="i++)</p">

{

pDest[i] = pSrc[i];

pSrc[i] = '\0';

}

return _pDest;

}

* 函数原形 void * memcpy(void* _pDest, const void* _pSrc, int _nCount);

* 表头文件 #include * 函数描述内存拷贝函数,将内存中的内容从一个地方拷贝到另一个地方

* 参数 _pSrc，源内存首地址

* _pDest,目的内存首地址

* 返回值目的内存首地址

* 作者武立强

* 时间 2009-04-08

* 备注

void * memcpy(void* _pDest, const void* _pSrc, int _nCount)

{

assert( _pDest && NULL != _pSrc);

char* pDest = (char*)_pDest;

char* pSrc = (char*)_pSrc;

for(int i=0; i<_ncount i>

{

pDest[i] = pSrc[i];

}

return _pDest;

}

* 函数原形 int CheckIsEmailStr(const char* _pStr);

* 表头文件 #include * 函数描述检查字符串是否是邮件格式, 即 xxx@xxx格式字符串

* 参数 _pStr，字符串的首地址

* 返回值 0, 正确

* -1,错误

* 作者武立强

* 时间 2009-04-08

* 备注

int CheckIsEmailStr(const char* _pStr)

{

assert(NULL != _pStr);

if( '\0' == *_pStr)

{

return (-1);

}

else

{

_pStr++;

}

while( '\0' != *_pStr )

{

if( '@' == *_pStr && '\0' != *(_pStr+1) )

{

return 0;

}

_pStr++;

}

return (-1);

}

* 函数原形 int IsPalindrome(const char* _pStr);

* 表头文件 #include * #include * #include * 函数描述判断一个字符串是否为回文，用栈的思路实现。

* 回文，即 abcba 形式，从前后看，字符串都一样。

* 参数 _pStr，要判断的字符串

* 返回值 0, 回文

* -1, 非回文

* 注释

int IsPalindrome(const char* _pStr)

{

assert( NULL != _pStr );

int nStrLen = 0; // 标志_pStr 的长度

int nHalfLen = 0; // 取其一半长度

int nStartIndex = 0; // 开始比较的下标

char* pData = NULL; // 存储数据首地址

nStrLen = strlen(_pStr);

if( 1 == nStrLen )

{

return 0; // 就一个字符，是回文

}

nHalfLen = nStrLen / 2; // 两个整数相除，结果取整

pData = (char*)malloc(sizeof(char)*(nHalfLen + 1));

if( NULL == pData )

{

printf("malloc error...");

return (-1);

}

// 将前一半字符取出

for(int i=0; i

{

pData[i] = _pStr[i];

}

pData[i] = '\0';

if( 0 == nStrLen%2 )

{

// _pStr 长度为偶数时

nStartIndex = nHalfLen;

}

else

{

// _pStr 长度为奇数时

nStartIndex = nHalfLen + 1;

}

// 逆序比较

for(i= nHalfLen -1; i>=0; i--)

{

if( pData[i] != _pStr[nStartIndex] )

{

free(pData); // 返回前释放内存

return (-1);

}

nStartIndex++;

}

free(pData);

return 0;

}

* 函数原形 int CheckBracketsIsMatch(const char* _pStr);

* 表头文件 #include * #include * #include * 函数描述检查一个字符串中的括号是否匹配(用栈的思路实现)

* 参数 _pStr，要判断的字符串

* 返回值 0, 匹配

* -1, 不匹配

* 注释

int CheckBracketsIsMatch (const char* _pStr)

{

assert( NULL != _pStr );

// 过滤字符串，只保留括号字符

char* pStr = (char*)malloc(strlen(_pStr) + 1);

if( NULL == pStr )

{

printf("malloc error...");

return (-1);

}

char* pStrFirst = pStr;

while( '\0' != *_pStr)

{

if( *_pStr == '[' || *_pStr == ']'

|| *_pStr == '{' || *_pStr == '}'

|| *_pStr == '(' || *_pStr == ')')

{

*pStr = *_pStr ;

pStr++;

}

_pStr++;

}

*pStr = '\0';

pStr = pStrFirst; // 将指针指向开头

int nStrLen = 0; // 标志 pStr 的长度

int nHalfLen = 0; // 取其一半长度

int nStartIndex = 0; // 开始比较的下标

char* pData = NULL;

nStrLen = strlen(pStr);

// 判断长度

if( 1 == nStrLen || 0 == nStrLen )

{

free(pStr);

return (-1); // 肯定不匹配

}

else if( 0 != nStrLen%2 )

{

// 长度为奇数,肯定不匹配

free(pStr);

return (-1);

}

nHalfLen = nStrLen / 2; // 两个整数相除，结果取整

pData = (char*)malloc(sizeof(char)*(nHalfLen + 1));

if( NULL == pData )

{

printf("malloc error...");

free(pStr);

return (-1);

}

// 将前一半字符取出

for(int i=0; i

{

pData[i] = pStr[i];

}

pData[i] = '\0';

nStartIndex = nHalfLen;

printf("----->%s \n", pStr);

printf("----->%s \n", pData);

// 逆序比较

for(i= nHalfLen -1; i>=0; i--)

{

if( ('[' == pData[i] && ']' != pStrspan style=span style=;color: rgb(0, 0, 204);[nStartIndex])

|| ('{' == pData[i] && '}' != pStr[nStartIndex])

|| ('(' == pData[i] && ')' != pStr[nStartIndex])

)

{

free(pStr);

free(pData); // 返回前释放内存

return (-1); // 不匹配

}

nStartIndex++;

}

free(pStr);

free(pData);

return 0;

}

/**************************************************

* 函数名: BSearch

* 参数:

* 形参:

* _pList : 顺序存储结构的线性表

* _key : 查找关键字

* _nLow : 查找范围下界

* _nHigh : 查找范围上界

* 返回值: 查找结果，-1表示查找失败，否则为查找到的元素下标

* 功能:

* 对顺序存储结构的线性表进行递归二分查找

* 作者: 左建华

* 编写明细:

* 2008-05-29 Created 左建华

**************************************************/

int BSearch(SeqList* _pList, DataType _key, int _nLow, int _nHigh)

{

if( _nLow>_nHigh )

{

return -1;

}

int nMiddle = (_nLow+_nHigh)/2;

if( _pList->data[nMiddle] == _key )

{

return nMiddle;

}

if( _pList->data[nMiddle] > _key )

{

return BSearch( _pList, _key, _nLow, nMiddle-1 );

}

else

{

return BSearch( _pList, _key, nMiddle+1, _nHigh );

}

* 函数原形 void DeleteRepeat(LinkList* _pHead);

* 表头文件 #include * #include * 函数描述删除链表中重复的数据，只保留一个

* 参数 _pHead，链表头结点指针

* 返回值 void

* 注释例如，链表中数据11123，运行此函数后数据变成123

void DeleteRepeat(LinkList _pHead)

{

assert( NULL != _pHead );

Node* pHere = NULL;

Node* pHereLast = NULL; // 当前结点

Node* pNode = _pHead; // 当前结点的上一个结点

while(pNode)

{

pHere = pNode->next;

pHereLast = pNode;

while(pHere) // 从pHere 开始，一直到链表结束

{

if(pHere->data == pNode->data)

{

// 重复数据结点,删除

pHereLast->next = pHere->next;

free(pHere);

pHere = pHereLast;

}

pHereLast = pHere;

pHere = pHere->next;

}

pNode = pNode->next;

}

* 函数原形 int Convert(int _nNum, int _nB, char* _pOutStr);

* 表头文件 #include * 函数描述将十进制的 Num (只能是正数)转换成 B 进制数，

* 以字符串的形式输出结果

* 参数 _nNum，使进制数

* _nB，表示要转换为 B 进制

* _pOutStr，(输出参数)转换后的字符串，要有足够的空间容纳转换后的字符串

* 返回值 0，成功

* -1，失败

* 注释目前不支持负数。思路：Num 除 B 取余到排

int Convert(int _nNum, int _nB, char* _pOutStr)

{

if( _nNum < 0 )

{

return (-1);

}

if( 0 == _nNum )

{

*_pOutStr = '0';

return 0;

}

int nTemp = _nNum;

int nLen = 0; //转换后的数的位数

// 计算转换后的数的位数

while( 1 != nTemp )

{

nTemp /= 2;

nLen++;

}

nLen += 1;

int* pB = (int*)malloc(sizeof(int)*nLen);

if( NULL == pB )

{

return (-1);

}

nTemp = _nNum;

for(int i=0; i

{

pB[i] = nTemp % 2;

nTemp /= 2;

}

// 输出转换后的 B 进制数(逆序输出)

for(i=nLen-1; i>=0; i--)

{

_pOutStr[(nLen-1) - i] = pB[i] + '0'; // 将整数转换为字符

}

_pOutStr[nLen] = '\0';

free(pB);

return 0;

}

weixin_39927059

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
linux函数怎么封装,常用的工具函数封装（4）

/**函数原形int FileCopy(const char* pDestFileName, const char* pSrcFileName);*表头文件#include*函数描述复制文件函数。将 pSrcFileName 文件复制到 pDestFileName 处，*如果 pDestFileName...
复制链接

扫一扫