38.C语言字符串总结

1.自己实现三个常用函数 strlen,strcpy,strstr

• 自己实现strstr函数，如果找到返回首地址，找不到则返回NULL

//查找元素，返回首地址
char *mystrstr(const char *_Str,const char *_SubStr)
{
    //如果有一个为空，则返回NULL
    if (_Str == NULL || _SubStr == NULL)
    {
        return NULL;
    }

    //psrc,psub保存源字符串和子字符串当前查询到的地址
    char *psrc = _Str;
    char *psub = _SubStr;

    //如果源字符串没有遍历晚，则继续遍历
    while (*psrc != '\0')
    {
        //创建新的临时地址，保存当前遍历到的地址
        char *ptmp_src = psrc;
        char *ptmp_sub = psub;
        int flag = 1;//首先假设字符串找到
        //如果自字符串没有遍历完，则继续遍历
        while (*ptmp_sub != '\0')
        {
            //如果源字符串提前结束，则返回NULL
            if (*ptmp_src == '\0')
            {
                return NULL;
            }
            //如果当前遍历到的不相等，则flag置0，跳出循环
            if (*ptmp_src != *ptmp_sub)
            {
                flag = 0;
                break;
            }
            else//否则同时向后移动一位
            {
                ptmp_src++;
                ptmp_sub++;
            }
        }
        //如果找到了返回首地址
        if (flag)
        {
            return psrc;
        }
        //如果没找到源字符串向后移动一位，再进行遍历
        psrc++;
    }

    return NULL;
}

 

• 自己实现strlen函数

unsigned int mystrlen(const char *str)
{
    int length = 0;
    for (int i = 0;; i++)
    {
        if (*(str + i) == '\0')
        {
            break;
        }
        length++;
    }
    return length;
}

• 自己实现strcpy函数

char *mystrcpy(char *dest, const char *source)
{
    if (dest == NULL || source == NULL)
    {
        return NULL;
    }
    for (int i = 0;; i++)
    {
        dest[i] = source[i];
        if (*(source + i) == '\0')
        {    
            break;
        }

        return dest;
    }
}

 2.字符串的排序以及自己实现strcmp

• 字符串的排序调用qsort

int compare(const void *p1, const void *p2)//传递的是数组元素的地址，类型是**，要先转化为**的指针
{
    const char **pstr1 = p1;
    const char **pstr2 = p2;
    //去每个元素首地址比较两个字符串
    return strcmp(*pstr1, *pstr2);
}

void main()
{
    char *str[10] = { "calc","apple","run","123" ,"boat","dead","father","son","hello","2018"};
    qsort(str, 10, 4, compare);
    for (int i = 0; i < 10; i++)
    {
        puts(str[i]);
    }
    system("pause");
}

•  字符串的排序，冒泡法

void main()
{
    char str[10][10] = { "calc","apple","run","123" ,"boat","dead","father","son","hello","2018" };

    for (int i = 0; i < 10 - 1; i++)//控制次数
    {
        for (int j = 0; j < 10  - i - 1; j++)//两个两个比较，大数沉底
        {
            if (strcmp(str[j], str[j + 1]) > 0)
            {
                char strtemp[100] = { 0 };
                strcpy(strtemp, str[j]);
                strcpy(str[j], str[j + 1]);
                strcpy(str[j + 1], strtemp);
            }
            
        }
    }
    for (int i = 0; i < 10; i++)
    {
        puts(str[i]);
    }
    system("pause");
}

•  自己实现strcmp

int mystrcmp(const char * _Str1, const char * _Str2)
{
    if (_Str1 == NULL || _Str2 == NULL)
    {
        return 0;
    }
    char *pstr1 = _Str1;
    char *pstr2 = _Str2;
    //一直循环到两个字符不相等
    while (*pstr1 == *pstr2 && *pstr1 != '\0')
    {
        pstr1++;
        pstr2++;
    }
    //如果都到两个字符串结尾
    if (*pstr1 == '\0' && *pstr2 == '\0')
    {
        return 0;
    }
    //如果有一个到结尾
    else if (*pstr1 == '\0' && *pstr2 != '\0')
    {
        return -1;
    }
    else if (*pstr1 != '\0' && *pstr2 == '\0')
    {
        return 1;
    }
    //如果都没到结尾
    else 
    {
        return *pstr1 > *pstr2 ? 1 : -1;
    }
}

不常用的字符串函数 

• 自己实现strset(char *p,char ch):填充字符串

  void mystrset(char *p, char ch)
  {
      while (*p!=NULL)
      {
          *p = ch;
          p++;
      }
  
  }

   

• 自己实现strrev(char *p)

  void mystrrev(char *p)
  {
      int len = strlen(p);
      for (int i = 0; i < len/2; i++)
      {
          p[i] = p[len - 1 -i];
      }
  }

   

• 自己实现_strlwr(字符串大写转小写)

  void mystrlwr(char *p)
  {
      while (*p != '\0')
      {
          if (*p >= 'A' && *p <= 'Z')
          {
              (*p) += 32;
          }
          p++;
      }
  }

   

• 自己实现_strupr(字符串小写转大写)

  void mystrupr(char *p)
  {
      while (*p != '\0')
      {
          if (*p >= 'a' && *p <= 'z')
          {
              (*p) -= 32;
          }
          p++;
      }
  }