常用字符串操作函数

1、字符串copy函数strcpy，实现如下:

#include <assert.h>
char *mystrcpy(char *dest,const char *sor)//将源字符sor串拷到目的字符串dest
{
    assert(dest);
    assert(sor);
    char *ret = dest;
    while(*dest++ = *sor++)
    {
        ;
    }
    return ret;
}

2、判断一个字符串中的子字符串strstr，实现如下：

 

#include <assert.h>
#include <stdio.h>
char *mystrstr(char *str_one,char *str_two)//判断str_two字符串是不是str_one字符串的子字符                                           //串
{
    char *pstr_one = NULL;
    char *pstr_two = NULL;
    while(*str_one)
    {
        pstr_one = str_one;
        pstr_two = str_two;
        while((*pstr_one)&&(*pstr_one == *pstr_two))
        {
            pstr_one++;
            pstr_two++;
            if(*pstr_two == '\0')
            {
                return str_one;
            }  
        }
        str_one++;
    }
    return NULL;
}

3、三种方法实现求取字符串长度strlen：

 

#include <assert.h>
//计数器实现strlen
//int mystrlen(const char *dest)
//{
//  assert(dest);
//  int count  = 0;
//  while(*dest)
//  {
//      count++;
//      dest++;
//  }
//  return count;
//}
//指针实现strlen
//int mystrlen(const char *dest)
//{
//  assert(dest);
//  int ret = 0;
//  const char *buff = dest;
//  while(*dest)
//  {
//      dest++;
//  }
//  ret = dest - buff;
//  return ret;
//}
//递归实现strlen
int mystrlen(const char *dest)
{
    assert(dest);
    if(*dest == '\0')
    {
        return 0;
    }
    dest++;
    return 1+mystrlen(dest);
}

4、字符串的比较strcmp，代码如下：

 

#include <assert.h>
int mystrcmp(const char *cmp1,const char *cmp2)
{
    assert(cmp1);
    assert(cmp2);
    int ret = 0;
    while(!(ret = (*(unsigned char*)cmp1 - *(unsigned char*)cmp2))&&*cmp2)
    {
        cmp1++;
        cmp2++;
    }
    if(ret>0)
        return 1;
    else if(ret<0)
        return -1;
    return 0;
}

5、字符串链接函数strcat，代码如下：

 

#include <assert.h>
char *mystrcat(char *dest,const char *sor)
{
    assert(dest);
    assert(sor);
    char *ret = dest;
    while(*dest)
    {
        dest++;
    }
    while(*dest++ =*sor++)
    {
        ;
    }
    return ret;
}

注意：对于一些特别的符号字符串处理函数就不能很好的解决了，比如要复制或链接两个内容都是'\0'，这样就不能很好解决问题。因此就引入了内存的复制和移动函数。

6、拷贝函数，memcpy函数，有三个参数，两个空类型指针（也叫做句柄）（表示可以接受任何类型的指针），一个count字符串大小。代码如下：

 

#include <assert.h>
void *mymemcpy(void *dest,const void *sor,int count)
{
    assert(dest);
    assert(sor);
    char *pdest = (char *)dest;
    char *psor = (char *)sor;
    void *ret = dest;
    while(count--)
    {
        *pdest++ = *psor++;
    }
    return ret;
}

注意这个函数的的缺点：导致内容被覆盖：

a b c d e f g h i j

比如：如果不abcd拷贝到cdef，则会导致cd被ab覆盖，输出的结果为：abababghij而不是：ababcdghij

因此引入，memmove函数。

7、memmove函数，拷贝内存函数，很好的解决的memcpy的不足，代码如下:

 

#include <assert.h>
void *mymemmove(void *dest,const void *sor,int count)
{
    assert(dest);
    assert(sor);
    char *pdest = (char *)dest;
    char *psor = (char *)sor;
    void *ret = dest;
    if(pdest>psor&&pdest<psor+count)//从后向前复制，这样就很好解决了memcpy的覆盖问题
    {
        while(count--)
        {
            *(pdest+count) = *(psor+count);
        }
    }
    else
    {
        while(count--)           
        {
            *pdest++ = *psor++;
        }
    }
    return ret;
}