[C++] #yyds干货盘点#编程之美-字符串函数

• 字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
  
• 参数指向的字符串必须要以 '\0' 结束。
  
• 注意函数的返回值为size_t，是无符号的
  
• 学会模拟实现。
  

size_t my_strlen(const char* parr)
{
  assert(parr);
  size_t count = 0;
  while (*parr++)
  {
    count++;
  }
  return count;
}

strlen("asd")-strlen("asdfg")不可能为负数的根本原因就是size_t

size_t my_strlen(const char* parr)
{
  assert(parr);//这是良好的代码规范
  if (*parr)
    return 1 + my_strlen(++parr);
  else
    return 0;
}

size_t my_strlen(const char* parr)
{
  assert(parr);//这是良好的代码规范
  char* head = parr;
  char* tail = parr;
  while (*tail)
  {
    tail++;
  }
  return tail - head;
}

• 源字符串必须以 '\0' 结束。
  
• 会将源字符串中的 '\0' 拷贝到目标空间。
  
• 目标空间必须足够大，以确保能存放源字符串。
  
• 目标空间必须可变。
  
• 学会模拟实现。
  

/*dest是destination目的地  src是source根源*/
char* my_strcpy(char* dest, const char* src)
{
  assert(dest && src);//保证指针有效性
  char* ret = dest;
  while (*dest++ = *src++);   
  return ret;
}

• 源字符串必须以 '\0' 结束。
  
• 目标空间必须有足够的大，能容纳下源字符串的内容。
  
• 目标空间必须可修改。
  
• 字符串自己给自己追加，如何？
  

/*dest是destination目的地  src是source根源*/
char* my_strcat(char* dest, const char* src)
{
  assert(dest && src);//保证指针有效性
  char* ret = dest;
  //1.找到目的字符串的'\0'
  while (*dest) 
  {
    dest++;
  }
  //2.然后再追加
  while (*dest++ = *src++);
  return ret;
}

• 第一个字符串大于第二个字符串，则返回大于0的数字
  
• 第一个字符串等于第二个字符串，则返回0
  
• 第一个字符串小于第二个字符串，则返回小于0的数字
  
• 那么如何判断两个字符串？
  

/*我们仅仅就是比较两个字符串，不希望改变他们，所以const*/
int my_strcmp(const char* str1, const char* str2)
{
  assert(str1 && str2);//保证指针有效性
  while (*str1 == *str2)
  {
    if (!*str1)
      return 0;//相等
    str1++;
    str2++;
  }
  if (*str1 > *str2)
    return 1;//大于
  else
    return -1;//小于
}

• 拷贝num个字符从源字符串到目标空间。
  
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
  

/*dest是destination目的地  src是source根源*/
char* my_strncpy(char* dest, const char* src,size_t count)
{
  assert(dest && src);//保证指针有效性
  char* ret = dest;
  while (count && (*dest++ = *src++))//count为0直接跳不会管你还有没有需要传的
  {
    count--;
  }
  if (count)//传完了用'\0'来补
  {
    while (count--)//这边不管先--还是后--都没事因为操作对象就是'\0'
      *dest = '\0';
  }
  return ret;
}

/*dest是destination目的地  src是source根源*/
char* my_strncat(char* dest, const char* src,size_t count)
{
  assert(dest && src);//保证指针有效性
  char* ret = dest;
  //1.找到目的字符串的'\0'
  while (*dest)
  {
    dest++;
  }
  //2.然后再追加
  while (count--)
  {
    if ((*dest++ = *src++) == 0)//count还没到0的时候已经赋\0去了就可以返回来了
    {
      return ret;
    }
  }
  *dest = '\0';//这是还没有赋\0，但count变成了0，就直接赋\0然后返回
  return ret;
}

int __cdecl strncmp
(
  const char *first,
  const char *last,
  size_t    count
)
{
  size_t x = 0;
  if (!count)
  {
    return 0;
  }
  /*
   * This explicit guard needed to deal correctly with boundary
   * cases: strings shorter than 4 bytes and strings longer than
   * UINT_MAX-4 bytes .
   */
  if( count >= 4 )
  {
    /* unroll by four */
    for (; x < count-4; x+=4)
    {
      first+=4;
      last +=4;
      if (*(first-4) == 0 || *(first-4) != *(last-4))
      {
        return(*(unsigned char *)(first-4) - *(unsigned char *)(last-4));
      }
      if (*(first-3) == 0 || *(first-3) != *(last-3))
      {
        return(*(unsigned char *)(first-3) - *(unsigned char *)(last-3));
      }
      if (*(first-2) == 0 || *(first-2) != *(last-2))
      {
        return(*(unsigned char *)(first-2) - *(unsigned char *)(last-2));
      }
      if (*(first-1) == 0 || *(first-1) != *(last-1))
      {
        return(*(unsigned char *)(first-1) - *(unsigned char *)(last-1));
      }
    }
  }
  /* residual loop */
  for (; x < count; x++)
  {
    if (*first == 0 || *first != *last)
    {
      return(*(unsigned char *)first - *(unsigned char *)last);
    }
    first+=1;
    last+=1;
  }
  return 0;
}

/*我们仅仅就是比较两个字符串，不希望改变他们，所以const*/
int my_strncmp(const char* str1, const char* str2,size_t count)
{
  assert(str1 && str2);//保证指针有效性
  while (count--)
  {
    if (*str1 - *str2 > 0)
      return 1;//大于
    else if (*str1 - *str2 < 0)
      return -1;//小于
    else
    {
      if (*str1 == *str2 && *str2== '\0')
        return 0;//相等
      str1++;
      str2++;
    }
  }
  return 0;//不在count内统统相等
}

/*我们仅仅就是找子字符串，不会改变他们，所以const*/
char* my_strstr(const char* str1, const char* str2)
{
  assert(str1 && str2);//保证指针有效性
  char* s1 = str1;//设置一个跟踪指针变量来代替str1
  char* s2 = str2;//设置一个跟踪指针变量来代替str2
  char* cur = str1;//设置一个原点指针变量来标置原来的查找位置，类似汇编中的call指令
  //排除空字符串
  if (!*str2)
    return str1;//这个是原函数规定的，所查字符串是空字符串的话返回str1
  //真正的查找过程
  while (*cur)
  {
    s1 = cur;//先把标记立在这cur
    s2 = str2;
    while (*s1 == *s2 && *s1 && *s2)
    {
      s1++;
      s2++;
    }
    if (!*s2)
      return cur;//找到就直接返回把标记地址返回
    cur++;//这是回到标记的下一个空间
  }
  return NULL;//没找到就返回空指针
}

• strDelimit参数是个字符串，定义了用作==分隔符的字符集合(Delimit 界限)==
  
• 第一个参数指定一个字符串，它包含了0个或者多个由strDelimit字符串中一个或者多个分隔符分割的标记。
  
• strtok函数找到strToken中的下一个标记，并将其用\0结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
  
• strtok函数的第一个参数不为NULL，函数将找到strToken中第一个标记，strtok函数将保存它在字符串中的位置。
  
• strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
  
• 如果字符串中不存在更多的标记，则返回 NULL 指针。
  

• 返回错误码，所对应的错误信息