字符、字符串函数与内存函数 2-阿里云开发者社区

1.7strncmp

int strncmp ( const char * str1, const char * str2, size_t num );

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

1.7.1strcmp使用

int main()
{
  char arr1[10] = "yuxiaoxia";
  char arr2[] = "yulanan";
  int ret = strncmp(arr1, arr2, 5);
  printf("%d \n", ret);
  return 0;
}

1.8strstr

char * strstr ( const char *str1, const char * str2);

返回一个指向str1中第一次出现的str2的指针，或者如果str2不是str1的一部分，则返回一个空指针。
在字符串str1中找子字符串str2

1.8.1strstr使用

int main()
{
  char* arr1 = "qwertyui";
  char* arr2 = "yu";
  char* ret = strstr(arr1, arr2);
  if (ret != NULL)
    printf("%s\n", ret);
  else
    printf("找不到\n");
  return 0;
}

1.8.2strstr模拟实现

char* my_strstr(const char* dest, const char* str)
{
  char* p = dest;
  char* s1 = p;
  char* s2 = str;
  if (*str == '\0')
    return dest;
  while (*p)
  {
    s1 = p;
    s2 = str;
    while ( *s1&& *s2 && *s1 == *s2)
    {
      s1++;
      s2++;
    }
    if (*s2 == '\0')
      return p;
    p++;
  }
  return NULL;
}
int main()
{
  char* arr1 = "qwertyui";
  char* arr2 = "we";
  char* ret = my_strstr(arr1, arr2);
  if (ret != NULL)
    printf("%s\n", ret);
  else
    printf("找不到\n");
  return 0;
}

1.9strtok

char * strtok ( char * str, const char * sep );

sep参数是个字符串，定义了用作分隔符的字符集合

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

如果字符串中不存在更多的标记，则返回 NULL 指针。

1.9.1strtok使用

int main()
{
  char arr[] = "56*fsf.fsafd@fd.5";
  char s[30];
  strcpy(s, arr);
  char tok[] = "*.@";
  char* ret = NULL;
  for (ret = strtok(s, tok); ret != NULL; ret = strtok(NULL, tok))
  {
    printf("%s\n", ret);
  }
  return 0;
}

1.10strerror

char * strerror ( int errnum );

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

#include <errno.h>必须包含的头文件

库函数在执行的时候，发生了错误，会将一个错误码存放到errno这个变量中，errno是C语言提供的一个全局变量

1.10.1strerror使用

#include <errno.h>
int main()
{
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d : %s\n", i, strerror(i));
  }
  return 0;
}

1.10.2perror扩展和文件基础操作

perror和strerror的区别在于：strerror把错误码翻译成错误信息，需要自行打印；perror既能找到错误信息，又能把错误信息打印出来，一步到位，括号内是自定义信息，错误信息会出现在自定义信息的后面

C语言文件操作：1.打开文件 2. 读写文件 3. 关闭文件

int main()
{
  FILE* p = fopen("dest.txt", "r"); //打开文件
  //读写文件
  //.......................
  if (p == NULL)    //判断文件是否存在
  {
    printf("fopen: %s\n", strerror(errno));//把错误码翻译成错误信息，需要自行打印
    perror("fopen");//既能找到错误信息，又能把错误信息打印出来
  }
  fclose(p); //关闭文件
  return 0;
}

2.字符分类函数

函数	如果它的参数符合下列条件就返回真

iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行'\n'，回车‘\r’，制表符'\t'或者垂直制表符'\v'

isdigit	十进制数字 0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F
islower	小写字母a~z

isupper	大写字母A~Z
isalpha	字母a~z或A~Z
isalnum	字母或者数字，a~z,A~Z,0~9

ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

2.1字符转化

#include <ctype.h>
int main()
{
  char arr[10] = { 0 };
  gets(arr);//gets会读入字符串，输入空格也会继续读，直到回车，读入回车前的所有数据
  char* p = arr;
  while (*p)
  {
    if (isupper(*p))  //判断字符是否是大写
    { 
      *p = tolower(*p);//将大写改为小写
    }
    p++;
  }
  printf("%s\n", arr);
  return 0;
}

3.内存函数

3.1memcpy

void * memcpy ( void * destination, const void * source, size_t num );

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

这个函数在遇到 '\0' 的时候并不会停下来。

如果source和destination有任何的重叠，复制的结果都是未定义的。

3.1.1memcpy使用

int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[20] = { 0 };
  memcpy(arr2, arr1, 40);
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", arr2[i]);
  }
  return 0;
}

3.1.2memcpy模拟实现

使用char*，因为字节管控更精准，这样num需要多少个字节，char*都能办到，一次只动一个字节，这样就不会写死，什么类型都可以实现

void* my_memcpy(void* dest, const void* str, size_t num)
{
  void* p = dest;
  assert(dest && str);
  while (num--)
  {
    *(char*)dest = *(char*)str;
    dest = (char*)dest + 1;
    str = (char*)str + 1;
  }
  return p;
}
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9};
  int arr2[20] = { 0 };
  int* p = my_memcpy(arr2, arr1, 40);
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", arr2[i]);
  }
  return 0;
}

3.1.3memcpy特殊情况

输出结果和预期会不一样，这是因为当拷贝的时候，前面的数据拿过来的时候被覆盖掉了，memcpy是用来处理两块不重叠（不相关）的内存拷贝的

void* my_memcpy(void* dest, const void* str, size_t num)
{
  void* p = dest;
  assert(dest && str);
  while (num--)
  {
    *(char*)dest = *(char*)str;
    dest = (char*)dest + 1;
    str = (char*)str + 1;
  }
  return p;
}
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10}; //1 2 1 2 3 4 5 8 9 10
  my_memcpy(arr1+2, arr1, 20);
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
  } 
  return 0;
}

3.2memmove

void * memmove ( void * destination, const void * source, size_t num );

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

3.2.1memmove使用

memmove就实现了上述memcpy没有完成的事情

int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10}; //1 2 1 2 3 4 5 6 7 8 
  memmove(arr1+2, arr1, 20);
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
  } 
  return 0;
}

3.2.2memmove模拟实现

void* my_memmove(char* dest, const char* str, size_t num)
{
  assert(dest && str);
  void* p = dest;
  if (dest < str) //从前往后放
  {
    while (num--)
    {
      *(char*)dest = *(char*)str;
      dest = (char*)dest + 1;
      str = (char*)str + 1;
    }
  }
  else     //从后往前放
  {
    while (num--)
    {
      *((char*)dest + num) = *((char*)str + num);
    }
  }
  return p;
}
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10}; 
  my_memmove(arr1, arr1+2, 20);
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
  } 
  return 0;
}

3.3memcmp

int memcmp ( const void * ptr1,

const void * ptr2,

size_t num );

比较从ptr1和ptr2指针开始的num个字节，比较的是在内存中字节的大小

返回值如下：

3.3.1memcmp使用

int main()
{
  int arr1[] = { 1,2,3,8 };
  int arr2[] = { 1,2,258 };
  int ret = memcmp(arr1, arr2, 10);
  printf("%d\n", ret);
  return 0;
}

3.4memset

void * memset ( void * ptr, int value, size_t num );

填充内存块：将 ptr 指向的内存块的num字节数设置为指定值，设置的是内存中字节的值

3.4.1memset使用

  int main()
  {
    char arr1[] = "good monvo";
    memset(arr1 + 5, 'x', 5);
    printf("%s\n", arr1);
    return 0;
  }

字符、字符串函数与内存函数 2