C字符串函数实现



 

转自：http://hi.baidu.com/dongxiang2007/blog/item/7184aa114e1ca3cca6ef3f3c.html

这里总结了一部分函数：memcpy,memset,memmove,strcpy,strcat,strlen,strcmp,strncmp,strstr等函数的具体实现过程。

#ifndef NULL
#define NULL ((void *)0)
#endif  
#include "stdio.h"
#include "stdlib.h"
#include

void* Mymemcpy(void *pDst, void *pSrc, size_t iLen)
{  
        assert((pDst!=NULL)&&(pSrc!=NULL));
        void *address=pDst;
        while((*((char *)pDst)++=*((char *)pSrc)++)!='/0')
                NULL;
        return address;  
}  


void* Mymemset(void *pDst, int iSet, size_t iLen)
{   
        assert(pDst!=NULL);
        char *pTmp = (char *)pDst;   
        if(0 == iLen)   
                return pDst;   
        while(iLen--)   
                *pTmp++ = (char)iSet;   
        return pDst;  
}  

char *Mystrcpy(char *pDst,const char *pSrc)   //复制字符串
{   
        assert((pDst!=NULL)&&(pSrc!=NULL));
        char *pRst = pDst;   
        do
        {
                *pDst++ = *pSrc;   
        }    
        while(*pSrc++);   
        return pRst;  
}   

char *Mystrcat(char *pDst,const char *pSrc)   //拼接字符串
{   
        assert((pDst!=NULL)&&(pSrc!=NULL));
        char *ptemp =pDst;   
        for(;*pDst; ++pDst);   
        while((*pDst++ = *pSrc++)!= '/0');   
        return ptemp;  
}  

size_t Mystrlen(const char *pStr)   //求字符串的长度
{   
        assert(pStr!=NULL);
        size_t iLen = 0;   
        while(*pStr++)   
                iLen++;   
        return iLen;  
}  

int Mystrcmp(const char *str1,const char *str2)//比较字符串的大小
{   
        assert((str1!=NULL)&&(str2!=NULL));
        for(; *str1 == *str2; str1++, str2++)   
        {   
                if(('/0' == *str1)||('/0' == *str2))   
                {   
                        if(*str1 == *str2)   
                                return 0;   
                        else
                                break;   
                }   
        }   
        return ((*str1 > *str2) ? 1 : -1);  
}


int Mystrncmp(const char *pStr1, const char *pStr2, int n)
{   
        assert((pStr1!=NULL)&&(pStr2!=NULL));
        if(0 == n)   
                return 0;   
        for (; (--n > 0) && (*pStr1==*pStr2); pStr1++,pStr2++)   
        {   
                if ('/0'==*pStr1)   
                        return 0;   
        }   
        if(*pStr1 == *pStr2)   
                return 0;   
        return ((*pStr1 > *pStr2) ? 1 : -1);  
}


char *Mystrstr (const char *pStr1, const char *pStr2)//字符串匹配函数实现
{
        assert((pStr1!=NULL)&&(pStr2!=NULL));
        unsigned int i = 0;
        if ( *pStr1 == 0 )                 // 如果字符串pStr1为空
        {
                if ( *pStr2 )                                 // 如果字符串pStr2不为空
                         return (char*)NULL;            // 则返回NULL
                return (char*)pStr1;                  // 如筽Str2也为空，则返籶Str1
        }
        while ( *pStr1 )                 // 串pStr1没有结束
        {
                i = 0;
                while (1)
                {
                        if ( pStr2[i] == 0 )
                        {
                                return (char*)pStr1;
                        }
                        if ( pStr2[i] != pStr1[i] )
                                break;
                        i++;
                }
                pStr1++;
        }
        return (char*)NULL;
}

char* Mystrstr1(char *s, char *find)   //字符串匹配函数实现
{   
        assert((s!=NULL)&&(find!=NULL));
        char c, sc;   
        unsigned int len;   

        if ((c = *find++) != 0)    
        {   
                len = Mystrlen(find);   
                do    
                {   
                        do    
                        {   
                                if ((sc = *s++) == 0)   
                                        return (NULL);   
                        } while (sc != c);   
                } while (Mystrncmp(s, find, len) != 0);   
                s--;   
        }   
        return ((char *)s); //返回的是匹配字符串的首地址位置
}

void * Mymemmove(void * dst,const void * src,size_t count)
{
        assert((dst!=NULL)&&(src!=NULL));
        void *ret=dst;
        if(dst <= src || (char*)dst >= ((char*)src + count))   
        {                               // dst<=src这里也可能出现内存重叠，但是它不会发生要转移的数据被覆盖的现象
                while(count--)   
                {
                        *(char *)dst = *(char *)src;
                        dst = (char *)dst + 1;
                        src = (char *)src + 1;
                }
        }
        else                     //出现内存重叠的情况，可能覆盖dst的内容(已经转移的数据被覆盖了)，
                                    //采用又高地址到低地址的赋值可避免这个现象
        {
                dst = (char *)dst + count - 1;                 //将指针移动到字符串的末尾
                src = (char *)src + count - 1;
                while(count--)                   //由末尾开始赋值。
                {
                        *(char *)dst=*(char *)src;
                        dst=(char *)dst-1;
                        src=(char *)src-1;
                }
        }
        return(ret);
}

int main()
{
        char dest[100];
        char src[100] = "donffjfjds";
        char str[100] = "fj";
       
    
       

       

       

       

       

       
       
    
        Mymemmove(dest,src,10);
        printf("%s",dest);
        system("PAUSE");
        return 0;
}

以下转自：http://hi.baidu.com/zhouwei0213/blog/item/507a2511787f45fbc2ce7903.html

#include
注意：对于指针型形参，一定要判断是否为空，一面地址越界！

char * ___strtok = NULL;

//复制
char * strcpy(char * dest,const char *src)
{

        if ((strDest==NULL)||(strSrc==NULL))
                 throw "Invalid argument(s)";
         char *tmp = dest;

         while ((*dest++ = *src++) != '/0')
                 ;
         return tmp;
}

//最多复制前count个字符串
char * strncpy(char * dest,const char *src,size_t count)
{

        if ((strDest==NULL)||(strSrc==NULL))
                 throw "Invalid argument(s)";

         char *tmp = dest;
         while (count-- && (*dest++ = *src++) != '/0')
                ;

         return tmp;
}

//字符串连接
char * strcat(char * dest, const char * src)
{

         if(dest == NULL) return src;

         else if(src == NULL) return dest;

         char *tmp = dest;
         while (*dest)
                 dest++;
         while ((*dest++ = *src++) != '/0');
         return tmp;
}

//连接前n个字符串（有问题）
char * strncat(char *dest, const char *src, size_t count)
{
         char *tmp = dest;
         if (count) {
                 while (*dest)
                         dest++;
                 while ((*dest++ = *src++)) {
                         if (--count == 0)
                                 break;
                 }
         }

         return tmp;
}

//比较

int strcmp(const char * cs,const char * ct)
{
         register signed char __res;

         while (1) {
                 if ((__res = *cs - *ct++) != 0 || !*cs++)
                         break;
         }

         return __res;
}

int strncmp(const char * cs,const char * ct,size_t count)
{
         register signed char __res = 0;

         while (count) {
                 if ((__res = *cs - *ct++) != 0 || !*cs++)
                         break;
                 count--;
         }

         return __res;
}

char * strchr(const char * s,char c)
{
         for(; *s != c; ++s)
                if (*s == '/0')
                         return NULL;
         return (char *) s;
}

size_t strlen(const char * s)
{
         const char *sc;

         for (sc = s; *sc != '/0'; ++sc)
                 ;
         return sc - s;
}

size_t strnlen(const char * s, size_t count)
{
         const char *sc;

         for (sc = s; *sc != '/0' && count--; ++sc)
                 ;
         return sc - s;
}
   
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;
}

char * bcopy(const char * src, char * dest, int count)
{
         char *tmp = dest;

        while (count--)
                 *tmp++ = *src++;

         return dest;
}

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;
}


void * memscan(void * addr, unsigned char c, size_t size)
{
         unsigned char * p = (unsigned char *) addr;

         while (size) {
                 if (*p == c)
                         return (void *) p;
                 p++;
                 size--;
         }
         return (void *) p;
}