C 某些库函数中字符串处理函数的具体实现

其中包括：strcpy(char *, char *),strncpy();strcat();strncat();strcmp();strncmp();strchr();strrchr();strlen();

strdup();strspn();strpbrk();strtok(); memset();memcpy();memmove();memcmp();memscan();strstr();

_strupr_();_strlen_();_strsplit_();_hex2dec_();_str2hex_();_str2dec_();

[cpp] view
plaincopy

/*=========================================================================

工程名称：C语言

[cpp] view
plaincopy

组成文件：string_lib.c

功能描述：常用C库函数的C实现

程序分析：

维护记录：

[cpp] view
plaincopy

=========================================================================*/

char * ___strtok = NULL;

char * strcpy(char * dest,const char *src)

{

char *tmp = dest;

while ((*dest++ = *src++) != '\0')

/* nothing */;

return tmp;

}

char * strncpy(char * dest,const char *src,size_t count)

{

char *tmp = dest;

while (count-- && (*dest++ = *src++) != '\0')

/* nothing */;

return tmp;

}

char * strcat(char * dest, const char * src)

{

char *tmp = dest;

while (*dest)

dest++;

while ((*dest++ = *src++) != '\0')

;

return tmp;

}

char * strncat(char *dest, const char *src, size_t count)

{

char *tmp = dest;

if (count)

{

while (*dest)

dest++;

while ((*dest++ = *src++))

{

if (--count == 0)

{

*dest = '\0';

break;

}

}

}

return tmp;

}

int strcmp(char *s1, char *s2)

{

while(*s1 && *s2)

{

if(*s1 - *s2)

return (*s1 - *s2);

s1++;

s2++;

}

if(*s1 != 0)

return 1;

else

return -1;

return 0;

}

int strncmp(char *s1, char *s2, int len)

{

while(len--)

{

if(*s1 && *s2)

{

if(*s1 - *s2)

return (*s1 - *s2);

s1++;

s2++;

}

else

{

if(*s1 || *s2)

return(*s1? *s1: *s2);

}

}

return 0;

}

char * strchr(const char * s, int c)

{

for(; *s != (char) c; ++s)

if (*s == '\0')

return NULL;

return (char *) s;

}

char * strrchr(const char * s, int c)

{

const char *p = s + strlen(s);

do

{

if (*p == (char)c)

return (char *)p;

}

while (--p >= s);

return NULL;

}

size_t strlen(const char * s)

{

const char *sc;

for (sc = s; *sc != '\0'; ++sc)

/* nothing */;

return sc - s;

}

char * strdup(const char *s)

{

char *new;

if ( (s == NULL) || ((new = malloc (strlen(s) + 1)) == NULL) )

{

return NULL;

}

strcpy (new, s);

return new;

}

size_t strspn(const char *s, const char *accept)

{

const char *p;

const char *a;

size_t count = 0;

for (p = s; *p != '\0'; ++p)

{

for (a = accept; *a != '\0'; ++a)

{

if (*p == *a)

break;

}

if (*a == '\0')

return count;

++count;

}

return count;

}

char * strpbrk(const char * cs,const char * ct)

{

const char *sc1,*sc2;

for( sc1 = cs; *sc1 != '\0'; ++sc1)

{

for( sc2 = ct; *sc2 != '\0'; ++sc2)

{

if (*sc1 == *sc2)

return (char *) sc1;

}

}

return NULL;

}

char * strtok(char * s,const char * ct)

{

char *sbegin, *send;

sbegin = s ? s : ___strtok;

if (!sbegin)

{

return NULL;

}

sbegin += strspn(sbegin,ct);

if (*sbegin == '\0')

{

___strtok = NULL;

return( NULL );

}

send = strpbrk( sbegin, ct);

if (send && *send != '\0')

*send++ = '\0';

___strtok = send;

return (sbegin);

}

void * memset(void * s,char c,size_t count)

{

char *xs = (char *) s;

while (count--)

*xs++ = c;

return s;

}

void * memcpy(void * dest,const void *src,size_t count)

{

char *tmp = (char *) dest, *s = (char *) src;

while (count--)

*tmp++ = *s++;

return dest;

}

void * memmove(void * dest,const void *src,size_t count)

{

char *tmp, *s;

if (dest <= src)

{

tmp = (char *) dest;

s = (char *) src;

while (count--)

*tmp++ = *s++;

}

else

{

tmp = (char *) dest + count;

s = (char *) src + count;

while (count--)

*--tmp = *--s;

}

return dest;

}

int memcmp(const void * cs,const void * ct,size_t count)

{

const unsigned char *su1, *su2;

signed char res = 0;

for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)

if ((res = *su1 - *su2) != 0)

break;

return res;

}

/*

* find the first occurrence of byte 'c', or 1 past the area if none

*/

void * memscan(void * addr, int c, size_t size)

{

unsigned char * p = (unsigned char *) addr;

while (size) {

if (*p == c)

return (void *) p;

p++;

size--;

}

return (void *) p;

}

char * strstr(const char * s1,const char * s2)

{

int l1, l2;

l2 = strlen(s2);

if (!l2)

return (char *) s1;

l1 = strlen(s1);

while (l1 >= l2)

{

l1--;

if (!memcmp(s1,s2,l2))

return (char *) s1;

s1++;

}

return NULL;

}

//=============================================================

// 语法格式： char *_strupr_(char *Str)

// 实现功能： 将字符串转换为全大写

// 参数： Str - 输入字符串首地址

// 返回值： 输出字符串首地址

// 注意: 该程序将直接修改原始字符串

//=============================================================

char *_strupr_(char *Str)

{

char *cp;

cp = Str;

while (*cp != 0)

{

if (*cp >= 'a' && *cp <= 'z' )

{

*cp -= 'a' - 'A';

}

cp++;

}

return Str;

}

//=============================================================

// 语法格式： int _strlen_(char *s)

// 实现功能： 求取字符串长度

// 参数： s - 输入字符串首地址

// 返回值： 字符串长度

//=============================================================

int _strlen_(char *s)

{

int i = 0;

while(*s)

{

i++;

s++;

}

return i;

}

//=============================================================

// 语法格式： int _strsplit_(char *sour, char *splstr, char *dest[])

// 实现功能： 字符串分割

// 参数： sour - 原始字符串首地址

// splstr - 分割字符串

// dest[] - 分割之后的每个字符串的首地址

// 返回值： 分割之后的字符串数量

//=============================================================

int _strsplit_(char *sour, char *splstr, char *dest[])

{

int i = 0;

int len;

char *cp;

if(*splstr == 0)

return 0;

cp = sour;

dest[i] = cp;

len = _strlen_(splstr);

while(*sour)

{

if(*sour == *splstr)

{

if(_strncmp_(sour, splstr, _strlen_(splstr)) == 0)

{

i++;

sour += len - 1;

*cp++ = 0;

dest[i] = cp;

}

}

else cp++;

sour++;

}

return (i + 1);

}

//=============================================================

// 语法格式： unsigned int _hex2dec_(unsigned int Binary)

// 实现功能： 二进制转BCD码(仅转换输入数据的低16bit)

// 参数： Binary - 输入数据

// 返回值： BCD码

//=============================================================

unsigned int _hex2dec_(unsigned int Binary)

{

unsigned int ulRet = 0;

Binary &= 0xffff;

while(Binary >= 10000)

{

ulRet += 10000;

Binary -= 10000;

}

while(Binary >= 1000)

{

ulRet += 0x1000;

Binary -= 1000;

}

while(Binary >= 100)

{

ulRet += 0x0100;

Binary -= 100;

}

while(Binary >= 10)

{

ulRet += 0x0010;

Binary -= 10;

}

ulRet += Binary;

return (ulRet);

}

//=============================================================

// 语法格式： int _str2hex_(char *s)

// 实现功能： 将一个字符串转换为十六进制数据

// 参数： s - 输入字符串

// 返回值： 字符串代表的十六进制数据

//=============================================================

int _str2hex_(char *s)

{

int Ret = 0;

s = _strupr_(s);

if((s[0] != '0') || (s[1] != 'X'))

return 0;

s += 2;

while(*s)

{

Ret <<= 4;

if((*s >= '0') && (*s <= '9'))

Ret += ((int)*s - '0');

else if((*s >= 'A') && (*s <= 'Z'))

Ret += ((int)*s - 'A' + 0x0a);

else

return 0;

s++;

}

return Ret;

}

//=============================================================

// 语法格式： int _str2dec_(char *s)

// 实现功能： 将一个字符串转换为十进制数据

// 参数： s - 输入字符串

// 返回值： 字符串代表的十进制数据

//=============================================================

int _str2dec_(char *s)

{

int Ret, Flag = 0;

Ret = 0;

if(*s == '-')

{

Flag = 1;

s++;

}

while(*s)

{

if((*s < '0') || (*s > '9'))

return 0;

Ret = Ret * 10 + (int)(*s - '0');

s++;

}

if(Flag)

Ret *= -1;

return Ret;

}