详解字符函数和内存函数

一.字符串函数

strlen

计算字符串中的长度，以‘\0’作为结束标志，不包含‘\0’，返回值是无符号的（size_t）。
strlen的模拟实现

strcpy

拷贝字符串

char* strcpy(char* der,const char* dea)
//der为目标字符串，dea为源字符串

1. 源字符串必须以’\0’结束
2. 目标空间必须足够大，能容纳下源字符串

strcyp的模拟实现

strcat

字符串的追加

char * strcat(char * drea,const char * der)

1. 源字符串必须以’\0’结束
2. 目标空间必须足够大，能容纳下源字符串
3. 字符串自己给自己追加
   strcat的模拟实现
   
   

strcmp

字符串的比较

int strcmp(const char* str1,const char* str2)
//第一个字符串大于第二个字符串，返回大于0的数
//第一和第二个字符串相等，返回0
//第一个字符串小于第二个字符串，返回小于0的数

strcmp比较的是字符串中对应位置的字符的ASCII值
strcmp的模拟实现

strstr

在一个字符串中寻找字符

char * strstr(const char*,const char *)

strstr的模拟实现

strtok

分割字符串

char * strtok(char* str,const char* sep)
//str是目标字符串，sep为分隔符集

1. strtok函数找到str中的下一个标记，并将用\0结尾，返回一个指向这个标记的指针。
2. strtok函数的第一个参数不为NULL,函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
3. strtok函数的第一个参数为NULL,函数将在同一个字符串被保存的位置开始，查找下一个标记
4. 如果字符串中不存在更多的标记，将返回NULL指针
   strtok的模拟实现

char *my_strtok(char *str,char *demion)
{
    static char *p_last = NULL;
    if(str == NULL && (str = p_last) == NULL)
    {
        return NULL;
    }   


      char *s = str;
      char *t= NULL;
      while(*s != '\0')
      {
          t= demion;
          while(*t != '\0')
          {
              if(*s == *t)
              {
                  p_last  = s +1;
                  if( s - str == NULL)
                  {
                      str = p_last;
                      break;
                  }
                  *s = '\0';
                  return str;
              }


              t++;
          }
          s++;
      }
      return NULL;
}
int main(void) 
{ 
  char str[] = "liusen,lin,lll";
  char * result = NULL;
  result = my_strtok(str,",");
  printf("%s\n",result);
  result = my_strtok(NULL,",");
  printf("%s\n",result);
   return 0; 
}

strerror

将错误码转换为错误信息，头文件<errno.h>

char * strerror(int errnum);

函数的应用

#include <stdio.h>
#include <string.h>
#include <errno.h>

int main()
{
    printf("%s\n", strerror(errno));

    return 0;
}

结果

rpz@funct:~$ ./a.out 
Success

内存操作函数

memcpy

void* memcpy(void* dest,const void* der,size_t mun)
//deat为目标，der为源，mun为要拷贝几个字节

• 遇到\0并不会停止
• 并不能预防内存重叠的问题
  memcpy的模拟实现
  

memmove

void* memmove(void * deat,const void* stuy,size_t mun)

功能和memcpy()基本相同，但优于memcpy,主要因为memmove()预防了内存重叠可能带来的问题
memmove的模拟实现

memcmp

int memcmp(const void* sref,const void* suyh,size_t mun)
//mun为共要比较的字节数，sref和suyh为要比较的对象

第一大于第二，返回大于0的数；
第一小于第二，返回小于0的数；
两对象等于时，返回0.
例：

#include <string.h>
main(){
    char *a = "aBcDeF";
    char *b = "AbCdEf";
    char *c = "aacdef";
    char *d = "aBcDeF";
    printf("memcmp(a, b):%d\n", memcmp((void*)a, (void*)b, 6));
    printf("memcmp(a, c):%d\n", memcmp((void*)a, (void*)c, 6));
    printf("memcmp(a, d):%d\n", memcmp((void*)a, (void*)d, 6));
}

结果为：
memcmp(a, b):1 //字符串a>字符串b, 返回1
memcmp(a, c):-1 // 字符串a<字符串c, 返回－1
memcmp(a, d):0 //字符串a＝字符串d, 返回0