实现string.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

#define SZ_SZIE 128

typedef char STRING[SZ_SZIE];

char * mystrcpy(char * dest, char * src);
int StrIsEmpty(char * str);
int mystrcmp(char * s1, char * s2);
int mystrlen(char * str);
int clearstr(char * str);
char * mystrcat(char * dest, char * src);
char * substring(char * sub, char * src, int pos, int len);
int Index(char * src, char * substr, int pos);
int Replace(char * src, char * oldstr, char * newstr);
int StrInsert(char * src, int pos, char * newstr);
int StrDelete(char * src, int pos, int len);
char * reverse1(char * str);
char * reverse2(char * str);
char * reverse3(char * str);

/*
函数功能:编程查找2个字符串的最大公共子串
比如:有2个字符串 A="aoabcp", B="gfabcm", 则返回输出:"abc"
*/

int main(int argc, char ** argv)
{
    freopen("string.txt", "w", stdout);
    printf("串的顺序存储！\n");
    STRING string;
    memset(string, 0, sizeof(STRING));
    char * str = mystrcpy(string, "abcdefg");
    printf("字符串复制函数，得到string  = [%s]\n", string);
    printf("字符串复制函数，返回得到str = [%s]\n", str);

    //memset(string, 0, sizeof(STRING));
    if(StrIsEmpty(string) == 1)
        printf("空串！\n");
    else
        printf("非空串！\n");

    int flag = mystrcmp(string, "abcdef");
    printf("字符串比较=[%d]\n", flag);

    //memset(string, 0, sizeof(STRING));
    //char * p = NULL;
    int len = mystrlen(string);
    printf("串长=[%d]\n", len);

    //clearstr(string);
    printf("清空串string=[%s]\n", string);

    char * str1 = mystrcat(string, "ABCabcdefgABCabcdefg");
    printf("串联接string=[%s]\n", string);
    printf("串联接str1=[%s]\n", str1);

    STRING substr;
    memset(substr, 0, sizeof(substr));
    char * str2 = substring(substr, string, 7, 3);
    printf("子串substr = [%s]\n", substr);
    printf("子串str2 = [%s]\n", str2);

    int index = Index(string, substr, 17);
    printf("[%s]串定位=[%d]\n", substr, index);

    STRING oldstr;
    memset(oldstr, 0, sizeof(oldstr));
    mystrcpy(oldstr, "ABC");
    STRING newstr;
    memset(newstr, 0, sizeof(newstr));
    mystrcpy(newstr, "linux");
    printf("替换前：string=[%s]\n", string);
    Replace(string, oldstr, newstr);
    printf("将串中[%s]替换成[%s]\n替换后：string=[%s]\n", oldstr, newstr, string);

    memset(oldstr, 0, sizeof(oldstr));
    mystrcpy(oldstr, "linux");
    memset(newstr, 0, sizeof(newstr));
    mystrcpy(newstr, "");
    //mystrcpy(newstr, "UNIX");
    Replace(string, oldstr, newstr);
    printf("将串中[%s]替换成[%s]\n替换后：string=[%s]\n", oldstr, newstr, string);

    STRING insertstr;
    memset(insertstr, 0, sizeof(insertstr));
    mystrcpy(insertstr, "SYSTEM");
    StrInsert(string, 3, insertstr);
    printf("串插入之后：string=[%s]\n", string);

    StrDelete(string, 10, 3);
    printf("串删除之后：string=[%s]\n", string);

    memset(string, 0, sizeof(STRING));
    strcpy(string, "0123456789");
    printf("字符串=[%s]", string);
    reverse1(string);
    printf(" 反转之后=[%s]\n", string);

    return 0;
}

/*功能：串插入*/
int StrInsert(char * src, int pos, char * newstr)
{
    assert((src != NULL)&&(newstr != NULL)&&(pos >= 0)&&(pos < mystrlen(src)));

    int movelen = 0; /*移动的距离*/
    int movenum = 0; /*移动的字符数*/
    int movebeg = 0; /*起始移动位置*/

    movelen = mystrlen(newstr);
    movenum = mystrlen(src) - pos;
    movebeg = mystrlen(src) - 1;

    while(movenum-- > 0)
    {
        *(src+movebeg+movelen) = *(src+movebeg); /*右移*/
        movebeg--;
    }

    while(*newstr != '\0') /*空出来的地方赋值新串*/
    {
        *(src+pos) = *newstr;
        src++;
        newstr++;
    }

    return 0;
}

/*功能：串删除
也可以使用memcpy(),strcpy(), strcat()函数来简化操作
*/
int StrDelete(char * src, int pos, int len)
{
    assert((src != NULL)&&(len >= 0)&&(len <= mystrlen(src))&&(pos >= 0)&&(pos < mystrlen(src)-len));

    int movelen = 0; /*移动的距离*/
    int movenum = 0; /*移动的字符数*/
    int movebeg = 0; /*起始移动位置*/

    movelen = len;
    movenum = mystrlen(src) - pos - len;
    movebeg = pos + len;

    while(movenum-- > 0)
    {
        *(src+movebeg-movelen) = *(src+movebeg); /*左移*/
        movebeg++;
    }

    return 0;
}

/*功能：串置换
也可以使用memcpy(),strcpy(), strcat()函数来简化操作
*/
int Replace(char * src, char * oldstr, char * newstr)
{
    assert((src != NULL)&&(oldstr != NULL)&&(newstr != NULL));
    int i = 0; /*主串下标*/
    int j = 0; /*子串下标*/
    int movenum = 0; /*移动的字符数*/
    int movelen = 0; /*移动的距离*/
    int movebeg = 0; /*起始移动位置*/

    if(mystrlen(oldstr) == mystrlen(newstr)) /*置换的字符长度不变，则不需要移动串中的元素*/
    {
        i = 0;
        while(i >= 0) /*i<0时：主串中没有oldstr字符串*/
        {
            i = Index(src, oldstr, i); /*在主串中定位oldstr字符串*/
            if(i < 0) /*主串中已经没有oldstr串了*/
                    break;
            j = 0;
            while(*(newstr+j) != '\0') /*置换*/
            {
                *(src+i) = *(newstr+j);
                i++;
                j++;
            }
        }
    }
    else if(mystrlen(oldstr) < mystrlen(newstr)) /*主串中的后面的元素需要后移*/
    {
        i = 0;
        while(i >= 0)
        {
            i = Index(src, oldstr, i); /*在主串中定位oldstr字符串*/
            if(i < 0) /*主串中已经没有oldstr字符串了*/
                    break;
            movelen = mystrlen(newstr) - mystrlen(oldstr); /*移动距离*/
            movenum = mystrlen(src) - i - mystrlen(oldstr); /*后移的字符数*/
            movebeg = mystrlen(src) - 1; /*起始移动位置：是最后一个字符,'\0'就不需要移动了*/

            while(movenum-- > 0) /*需要移动完所有的字符*/
            {
                *(src+movebeg+movelen) = *(src+movebeg);
                movebeg--; /*从最后一个字符开始,向后移动*/
            }

            j = 0;
            while(*(newstr+j) != '\0') /*置换*/
            {
                *(src+i) = *(newstr+j);
                i++;
                j++;
            }
        }
    }
    else if(mystrlen(oldstr) > mystrlen(newstr)) /*主串中的后面的元素需要前移*/
    {
        i = 0;
        while(i >= 0)
        {
            i = Index(src, oldstr, i); /*在主串中定位oldstr字符串*/
            if(i < 0) /*主串中已经没有oldstr字符串了*/
                    break;
            movelen = mystrlen(oldstr) - mystrlen(newstr); /*移动距离*/
            /*movenum:前移的字符数:应该把后面的清'\0'，所以多移动几个字符*/
            movenum = mystrlen(src) - i - mystrlen(oldstr) + movelen;
            movebeg = i + mystrlen(oldstr); /*起始移动位置：是第1个字符*/

            while(movenum-- > 0) /*需要移动完所有的字符*/
            {
                *(src+movebeg-movelen) = *(src+movebeg);
                movebeg++; /*从第一个字符开始，向前移动*/
            }

            j = 0;
            while(*(newstr+j) != '\0') /*置换*/
            {
                *(src+i) = *(newstr+j);
                i++;
                j++;
            }
        }
    }
    return 0;
}

/*功能：串定位：*/
int Index(char * src, char * substr, int pos)
{
    assert((src != NULL)&&(pos >= 0)&&(pos < mystrlen(src)));
    int i = 0; /*主串下标*/
    int j = 0; /*子串下标*/
    while((i < mystrlen(src)-pos-1)&&(j < mystrlen(substr)))
    {
        if(*(src+pos+i) == *(substr+j)) /*有相等，则继续比较后继的字符*/
        {
            i++;
            j++; /*直到比较完所有的子串*/
        }
        else /*i指针回退，重新开始匹配。i是主串下次匹配的起始地址，j是子串的起始地址*/
        {
            i = i-j+1; /*主串回到上一次比较的起始位置的下一个位置*/
            j = 0;
        }
    }
    if(j >= strlen(substr)) /*while循环结束时：j已经等于子串的长度*/
        return pos + (i - strlen(substr)); /*pos下标之后：子串在主串中第一次出现的位置*/
    else
        return -1;
}

/*功能：求子串（用sub返回串src的第pos个字符起长度为len的子串）*/
char * substring(char * sub, char * src, int pos, int len)
{
    assert((src != NULL)&&(pos >= 0)&&(pos <= mystrlen(src))&&(len > 0)&&(len < mystrlen(src)-pos));
    char * addr = sub;
    int i = 0;
    while(i < len)
    {
        *(sub+i) = *(src+pos+i);
        i++;
    }

    return addr;
}

/*功能：串联接*/
char * mystrcat(char * dest, char * src)
{
    assert((dest != NULL)&&(src != NULL));
    char * addr = dest;
    while(*dest != '\0')
    {
        dest++;
    }
    while((*dest++ = *src++) != '\0');

    return addr;
}

/*功能：清空串*/
int clearstr(char * str)
{
    assert(str != NULL);
    while(*str != '\0')
    {
        *str++ = '\0';
    }
    return 0;
}

/*功能：求串长*/
int mystrlen(char * str)
{
    assert(str != NULL);
    int len = 0;
    while((*str++) != 0)
    {
        len++;
    }
    return len;
}

/*功能：串比较*/
int mystrcmp(char * s1, char * s2)
{
    assert((s1 != NULL)&&(s2 != NULL));
    int flag = 0;
    while(flag == 0)
    {
        flag = *s1 - *s2;
        if((flag == 0)&&(*s2 != '\0')) /*此处比较还相等，并且字符串还没有结束，要继续下一个比较*/
        {
            s1++;
            s2++;
            continue;
        }
        else if((flag == 0)&&(*s2 == '\0')) /*此处比较还相等，并且字符串已结束，说明字符串是相等*/
        {
            flag = 0;
            break;
        }
        else if(flag != 0) /*此处比较不相等了，后面不需要比较了*/
        {
            break;
        }
    }
    return flag;
}

/*功能：判断串是否为空:1：空串，2：非空串*/
int StrIsEmpty(char * str)
{
    assert(str != NULL);
    if(*str == '\0') /*空串*/
        return 1;
    else /*非空串*/
        return 2;
}

/************************************************************
 *函数名：
 *函数功能：字符串的复制
 *函数参数：
 *编程方法：
 *1,
    int i = 0;
    while(*(src+i) != '\0')
    {
        *(dest+i) = *(src+i);
        i++;
    }
 *2,
    while(*src != '\0')
    {
        *dest = *src;
        dest++;
        src++;
    }
 *3,
    while(*src != '\0')
    {
        *dest++ = *src++;
    }
*************************************************************/
char * mystrcpy(char * dest, char * src)
{
    assert((dest != NULL)&&(src != NULL));
    char * addr = dest;
    while((*dest++ = *src++) != '\0');
    return addr;
}

/*功能：将字符串反转的递归算法*/
char * reverse1(char * str)
{
    if(str == NULL)
        return NULL;
    int len=strlen(str);
    if(len > 1)
    {
        char ctemp=str[0];
        str[0]=str[len-1];
        str[len-1]='\0';

        reverse1(str+1);
        str[len-1]=ctemp;
    }
    return str;
}

/*功能：将字符串反转的另一种递归算法*/
char * reverse2(char * str)
{
    if(str == NULL)
        return NULL;
    int len = strlen(str);
    if(len > 1)
    {
        char temp = str[0];
        str[0] = str[len-1];
        str[len-1] = temp;

        char newstr[len+1];
        memset(newstr, 0, sizeof(newstr));
        int newlen = strlen(str) - sizeof(char)*2;
        if(newlen > 1)
        {
            memcpy(newstr, str+sizeof(char)*1, sizeof(char)*newlen);
            reverse2(newstr);
            memcpy(str+sizeof(char)*1, newstr, sizeof(char)*newlen);
        }
    }
    return str;
}

/*功能：非递归实现字符串的反转*/
char * reverse3(char * str)
{
    if(str == NULL)
        return NULL;
    char * head = str;
    char * tail = str + strlen(str) -1;
    char temp;
    while(head < str + strlen(str)/2)
    {
        temp = *head;
        *head++ = *tail;
        *tail-- = temp;
    }
    return str;
}






























/*
 * linux/lib/string.c
 *
 * Copyright (C) 1991, 1992  Linus Torvalds
 */

extern void putc(unsigned char c);
int puts(const char *s)
{
    int i = 0;
    while (*s) {
        putc(*s);
        s++;
        i++;
    }
    putc('\n');
    putc('\r');
    return i+2;
}

int putchar(int c)
{
    putc((unsigned char)c);
    return c;
}

/**
 * strnicmp - Case insensitive, length-limited string comparison
 * @s1: One string
 * @s2: The other string
 * @len: the maximum number of characters to compare
 */
int strnicmp(const char *s1, const char *s2, size_t len)
{
    /* Yes, Virginia, it had better be unsigned */
    unsigned char c1, c2;

    c1 = 0;    c2 = 0;
    if (len) {
        do {
            c1 = *s1; c2 = *s2;
            s1++; s2++;
            if (!c1)
                break;
            if (!c2)
                break;
            if (c1 == c2)
                continue;
            c1 = tolower(c1);
            c2 = tolower(c2);
            if (c1 != c2)
                break;
        } while (--len);
    }
    return (int)c1 - (int)c2;
}

char * ___strtok;

/**
 * strcpy - Copy a %NUL terminated string
 * @dest: Where to copy the string to
 * @src: Where to copy the string from
 */
char * strcpy(char * dest,const char *src)
{
    char *tmp = dest;

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

/**
 * strncpy - Copy a length-limited, %NUL-terminated string
 * @dest: Where to copy the string to
 * @src: Where to copy the string from
 * @count: The maximum number of bytes to copy
 *
 * Note that unlike userspace strncpy, this does not %NUL-pad the buffer.
 * However, the result is not %NUL-terminated if the source exceeds
 * @count bytes.
 */
char * strncpy(char * dest,const char *src,size_t count)
{
    char *tmp = dest;

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

    return tmp;
}

/**
 * strcat - Append one %NUL-terminated string to another
 * @dest: The string to be appended to
 * @src: The string to append to it
 */
char * strcat(char * dest, const char * src)
{
    char *tmp = dest;

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

    return tmp;
}

/**
 * strncat - Append a length-limited, %NUL-terminated string to another
 * @dest: The string to be appended to
 * @src: The string to append to it
 * @count: The maximum numbers of bytes to copy
 *
 * Note that in contrast to strncpy, strncat ensures the result is
 * terminated.
 */
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;
}

/**
 * strcmp - Compare two strings
 * @cs: One string
 * @ct: Another string
 */
int strcmp(const char * cs,const char * ct)
{
    register signed char __res;

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

    return __res;
}

/**
 * strncmp - Compare two length-limited strings
 * @cs: One string
 * @ct: Another string
 * @count: The maximum number of bytes to compare
 */
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;
}

/**
 * strchr - Find the first occurrence of a character in a string
 * @s: The string to be searched
 * @c: The character to search for
 */
char * strchr(const char * s, int c)
{
    for(; *s != (char) c; ++s)
        if (*s == '\0')
            return NULL;
    return (char *) s;
}

/**
 * strrchr - Find the last occurrence of a character in a string
 * @s: The string to be searched
 * @c: The character to search for
 */
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;
}

/**
 * strlen - Find the length of a string
 * @s: The string to be sized
 */
size_t strlen(const char * s)
{
    const char *sc;

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

/**
 * strnlen - Find the length of a length-limited string
 * @s: The string to be sized
 * @count: The maximum number of bytes to search
 */
size_t strnlen(const char * s, size_t count)
{
    const char *sc;

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

/**
 * strspn - Calculate the length of the initial substring of @s which only
 *     contain letters in @accept
 * @s: The string to be searched
 * @accept: The string to search for
 */
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;
}

/**
 * strpbrk - Find the first occurrence of a set of characters
 * @cs: The string to be searched
 * @ct: The characters to search for
 */
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;
}

/**
 * strtok - Split a string into tokens
 * @s: The string to be searched
 * @ct: The characters to search for
 *
 * WARNING: strtok is deprecated, use strsep instead.
 */
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);
}

/**
 * strsep - Split a string into tokens
 * @s: The string to be searched
 * @ct: The characters to search for
 *
 * strsep() updates @s to point after the token, ready for the next call.
 *
 * It returns empty tokens, too, behaving exactly like the libc function
 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
 * Same semantics, slimmer shape. ;)
 */
char * strsep(char **s, const char *ct)
{
    char *sbegin = *s, *end;

    if (sbegin == NULL)
        return NULL;

    end = strpbrk(sbegin, ct);
    if (end)
        *end++ = '\0';
    *s = end;

    return sbegin;
}

/**
 * memset - Fill a region of memory with the given value
 * @s: Pointer to the start of the area.
 * @c: The byte to fill the area with
 * @count: The size of the area.
 *
 * Do not use memset() to access IO space, use memset_io() instead.
 */
void * memset(void * s,int c,size_t count)
{
    char *xs = (char *) s;

    while (count--)
        *xs++ = c;

    return s;
}

/**
 * bcopy - Copy one area of memory to another
 * @src: Where to copy from
 * @dest: Where to copy to
 * @count: The size of the area.
 *
 * Note that this is the same as memcpy(), with the arguments reversed.
 * memcpy() is the standard, bcopy() is a legacy BSD function.
 *
 * You should not use this function to access IO space, use memcpy_toio()
 * or memcpy_fromio() instead.
 */
void bcopy(const void *src, void *dest, size_t count)
{
    char *destTmp = (char *)dest;
    char *srcTmp = (char *)src;

    while (count--)
        *destTmp++ = *srcTmp++;
}

/**
 * memcpy - Copy one area of memory to another
 * @dest: Where to copy to
 * @src: Where to copy from
 * @count: The size of the area.
 *
 * You should not use this function to access IO space, use memcpy_toio()
 * or memcpy_fromio() instead.
 */
void * memcpy(void * dest,const void *src,size_t count)
{
    char *tmp = (char *) dest, *s = (char *) src;

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

    return dest;
}

/**
 * memmove - Copy one area of memory to another
 * @dest: Where to copy to
 * @src: Where to copy from
 * @count: The size of the area.
 *
 * Unlike memcpy(), memmove() copes with overlapping areas.
 */
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;
}

/**
 * memcmp - Compare two areas of memory
 * @cs: One area of memory
 * @ct: Another area of memory
 * @count: The size of the area.
 */
int memcmp(const void * cs,const void * ct,size_t count)
{
    const unsigned char *su1, *su2;
    int res = 0;

    for( su1 = (const unsigned char *)cs, su2 = (const unsigned char *)ct; 0 < count; ++su1, ++su2, count--)
        if ((res = *su1 - *su2) != 0)
            break;
    return res;
}

/**
 * memscan - Find a character in an area of memory.
 * @addr: The memory area
 * @c: The byte to search for
 * @size: The size of the area.
 *
 * returns the address of the first occurrence of @c, or 1 byte past
 * the area if @c is not found
 */
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;
}
#endif

/**
 * strstr - Find the first substring in a %NUL terminated string
 * @s1: The string to be searched
 * @s2: The string to search for
 */
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;
}

/**
 * memchr - Find a character in an area of memory.
 * @s: The memory area
 * @c: The byte to search for
 * @n: The size of the area.
 *
 * returns the address of the first occurrence of @c, or %NULL
 * if @c is not found
 */
void *memchr(const void *s, int c, size_t n)
{
    const unsigned char *p = (const unsigned char *)s;
    while (n-- != 0) {
            if ((unsigned char)c == *p++) {
            return (void *)(p-1);
        }
    }
    return NULL;
}