常用的库函数原型

#include
#include

typedef unsigned char BYTE;
typedef int INT32;
typedef int INT;
typedef unsigned int UINT32;
typedef int S32;
typedef void VOID;
typedef unsigned char UINT8;
typedef unsigned short UINT16;
typedef FILE* FS_HANDLE;
typedef unsigned char U8;
typedef unsigned short U16;
typedef short S16;
typedef short INT16;
typedef int boolean;
typedef int BOOL;

/****************************************************************************
函数:memcpy()
原型:void memcpy(void* dest, void* src, int count);
功能:memcpy是对内存的拷贝,对其他安全性不做考虑.
使用这个函数时要小心,比如用它来拷贝字符串就要注意末尾的\0字符之类的。
****************************************************************************/
void memcpy(void* dest, void* src, int count)
{

char* pbTo = (char*)dest;

char* pbFrom = (char*)src;

assert(dest != NULL && src != NULL); //检查输入指针的有效性

assert(pbTo>=pbFrom+count || pbFrom>=pbTo+count);//检查两个指针指向的内存是否重叠

while(count-->0)
{
*pbTo++ = *pbFrom++;
}

return;
}

/***************************************************************************
函数:memmove()
原型:void* memmove(void* dest, const void* src,size_t num);
功能:src拷贝count个字符到dest,如果目标区域和源区域有重叠的话,
memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中.
但复制后src内容会被更改.但是当目标区域与源区域没有重叠则和memcpy函数功能相同
****************************************************************************/
void* memmove(void* dest, const void* src,size_t num)
{
assert((dest!=NULL) && (src!=NULL) && (dest!=src));

char* p_dest = (char*)dest;
const char* p_src = (const char*)src;

if(p_dest>p_src && p_dest{ //p_dest>p_src，逆向拷贝
p_dest += num - 1;
p_src += num - 1;
while(num--)
*p_dest-- = *p_src--;
}
else
{ //p_dest<=p_src，此时无论是否重叠都可以使用正向拷贝
while(num--)
{
*p_dest++ = *p_src++;
}
}
return dest;
}

/*****************************************************************
函数:memset()
原型:void* memset(void* buffer, int c, int count);
功能:把s所指向的地址开始的n个字节的内容全部置位ch所指定的ASCII值
*****************************************************************/
void* memset(void* buffer, int c, int count)
{

char* pvTo=(char*)buffer;

assert(buffer != NULL);

while(count-->0)
{
*pvTo++=(char)c;
}

return buffer;
}

/*****************************************************************
函数:strcpy()
原型:char * strcpy( char* _Dest, const char *_Source );
功能:
.复制源串_Source到目标串_Dest所指定的位置, 包含NULL结束符
.不能处理源串与目标串重叠的情况
.函数返回_Dest

值.
*****************************************************************/
char * strcpy( char *_Dest, const char *_Source )
{
assert( ( NULL != _Dest ) && ( NULL != _Source ) );

char *_Temp = _Dest;

while ((*_Temp++ = *_Source++ ) != '\0' );

return _Dest;
}

/****************************************************************************
函数:strlen()
原型:size_t strlen( const char *_Str );
功能:获取字符串长度, 字符串结束符NULL不计算在内.没有返回值指示操作错误.
****************************************************************************/
size_t strlen( const char *_Str )
{
assert( _Str != NULL );

size_t _Size = 0;

while ( *_Str++ )
{
_Size++;
}
return _Size;
}

/****************************************************************************
函数:strcat()
原型:char * strcat( char *_Dest, const char *_Source );
功能:将源串_Src字符添加到目标串_Dst后.本函数不能处理源串与目标串重叠的情况.
****************************************************************************/
char * strcat( char *_Dest, const char *_Source )
{
assert( ( NULL != _Dest ) && ( NULL != _Source ) );

char *_Temp = _Dest;

while ( ( *++_Temp ) != NULL );

while ( ( *_Temp++ = *_Source++ ) != NULL );

return _Dest;
}

/*****************************************************************
函数:strcmp()
原型:int strcmp( const char *_Str1, const char *_Str2 );
功能:比较字符串_Str1和_Str2大小.
返回值< 0, 表示_Str1小于_Str2;
返回值为0, 表示_Str1等于_Str2;
返回值> 0, 表示_Str1大于_Str2.
*****************************************************************/
int strcmp( const char *_Str1, const char *_Str2 )
{
assert( ( NULL != _Str1 ) && ( NULL != _Str2 ) );

for ( ; *_Str1 == *_Str2; _Str1++, _Str2++ )
{
if ( ( '\0' == *_Str1 ) || ( '\0' == *_Str2 ) )
{
if ( *_Str1 == *_Str2 )
{
return 0;
}
else
{
break;
}
}
}
return ( ( *_Str1 > *_Str2 ) ? 1 : -1 );
}

/*****************************************************************
函数:strlwr()
原型:char * strlwr( char *_Str );
功能:将字符串_Str的大写转换成小写并输出.
*****************************************************************/
char * strlwr( char *_Str )
{
assert( NULL != _Str );

char *_Temp = _Str;

do
{
if ( ( *_Temp >= 'A' ) && ( *_Temp <= 'Z' ) )
{
*_Temp += 32;
}
}while( ( *_Temp++ ) != '\0' );
return _Str;
}

/*****************************************************************
函数:strupr()
原型:char * strupr( char *_Str );
功能:将字符串_Str的小写转换成大写并输出.
*****************************************************************/
char * strupr( char *_Str )
{
assert( NULL != _Str);

char *_Temp = _Str;

do
{
if ( ( *_Temp >= 'a' ) && ( *_Temp <= 'z' ) )
{
*_Temp -= 32;
}
}while( (

*_Temp++ ) != '\0' );

return _Str;
}


/*****************************************************************
函数:strrev的实现代码
原型:char * strrev( char *_Str );
功能:将字符串_Str倒转并输出.
*****************************************************************/
char * strrev( char *_Str )
{
assert( NULL != _Str );

char *_Str1 = _Str;
char *_Str2 = _Str;
char _Temp;

while ( *_Str2 != '\0' )
{
*_Str2++;
}

if( _Str1 != _Str2 )
{
_Str2--;
}

while ( _Str1 < _Str2 )
{
_Temp = *_Str1;
*_Str1 = *_Str2;
*_Str2 = _Temp;
*_Str1++;
*_Str2--;
}

return _Str;
}

/****************************************************************************
函数:strchr()
原型:const char * strchr( const char *_Str, int _Val );
功能:函数返回一个指向Str中_Val首次出现的位置,当没有在_Str中找_Val到返回NULL.
****************************************************************************/
const char * strchr( const char *_Str, int _Val )
{
assert( NULL != _Str );

for ( ;*_Str != (char)_Val; ++_Str )
{
if ( *_Str == '\0' )
{
return (const char *)NULL;
}
}

return _Str;
}

/****************************************************************************
函数:strchr()
原型:const char * strchr( const char *_Str, int _Val );
功能:函数返回一个指向Str中_Val首次出现的位置，当没有在_Str中找_Val到返回NULL。
****************************************************************************/
char * strpbrk( char *_Str, const char *_Control )
{
assert( ( NULL != _Str ) && (NULL != _Control ) );

char *_Str1;
const char *_Str2;

for ( _Str1 = _Str; *_Str1 != '\0'; ++_Str1 )
{
for ( _Str2 = _Control; *_Str2 != '\0'; ++_Str2 )
{
if ( *_Str1 == *_Str2 )
{
return _Str1;
}
}
}
return (char*)NULL;
}

/****************************************************************************
函数:strstr()
原型:char * strstr( char *_Str, const char *_SubStr );
功能:在字符串_Str中查找_SubStr子串.
返回子串_SubStr在_Str中首次出现位置的指针.
如果没有找到子串_SubStr,则返回NULL. 如果子串_SubStr为空串,函数返回_Str值.
****************************************************************************/
char * strstr( char *_Str, const char *_SubStr )
{
assert( ( NULL != _Str ) && ( NULL != _SubStr ) );

unsigned int i = 0;

if ( 0 == *_Str )
{
if ( *_SubStr )
{
return (char*)NULL;
}
return _Str;
}
while ( *_Str )
{
i = 0;

while (1)
{
if ( 0 == _SubStr[i] )
{
return _Str;
}
if ( _SubStr[i] != _Str[i] )
{
break;
}
i++;
}
_Str++;
}
return (char*)NULL;
}

/****************************************************************************
函数:strtok()
原型:char * strtok( char *_Str, const char *_Delim );
功能:查找由_Delim指定分

界符对_Str进行分解.
首次调用_str指向要分解的字符串以后调用_Str为NULL.
****************************************************************************/
char * strtok( char *_Str, const char *_Delim )
{
static char *_Begin;

if ( NULL != _Str )
{
_Begin = strstr( _Str, _Delim );
while ( _Begin == _Str )
{
_Str += strlen( _Delim );
_Begin = strstr( _Str, _Delim );
}
}
else
{
_Str = _Begin;
if ( NULL == _Str )
{
return NULL;
}
_Begin = strstr( _Str, _Delim );
while ( _Begin == _Str )
{
_Str += strlen( _Delim );
_Begin = strstr( _Str, _Delim );
}
}
if ( NULL != _Begin )
{
memset( _Begin, 0, strlen( _Delim ) );
_Begin += strlen( _Delim );
}
else if ( 0 == *_Str )
{
return NULL;
}
return _Str;
}

char* strncpy(char* dest, const char* src, int len)
{
assert(dest!=NULL && src!=NULL);

char* temp=dest;
int i=0;

while(i++ < len && (*temp++ = *src++)!='\0')
{}

if(*(--temp)!='\0')
{
*temp='\0';
}

return dest;
}

/***********************************************************************************
函数:substr()
原型:void substr(char *dest,const char* src,unsigned int start,unsigned int cnt);
功能:从src的偏移量为start,连续复制cnt个字符,组成字符串dest
***********************************************************************************/
void substr(char *dest, const char* src, unsigned int start, unsigned int cnt)
{
strncpy(dest, src + start, cnt);
dest[cnt] = 0;
}

/*****************************************************************
函数:Str_to_Hex()
原型:UINT16 Str_to_Hex(UINT8* str);
功能:将字符串转换成16进制数字
*****************************************************************/
UINT16 Str_to_Hex(UINT8* str)
{
UINT16 var=0;
UINT16 t;
UINT16 len = strlen(str);

if (var > 8) //最长8位
{
return -1;
}
strupr(str);//统一大写
for (; *str; str++)
{
if (*str>='A' && *str <='F')
{
t = *str-55;//a-f之间的ascii与对应数值相差55如'A'为65,65-55即为A
}
else
{
t = *str-48;
}
var<<=4;
var|=t;
}
return var;
}

int main(void)
{
char a[3] = "sd";
strrev(a);
printf("%s",a);
printf("............%d\n",sizeof(UINT16));
return 0;
}