字符函数和字符串函数（下）——“C”-阿里云开发者社区

各位CSDN的uu们你们好呀，今天小雅兰的内容依旧是字符函数和字符串函数呀，这篇博客会讲一些内存相关的函数，下面，让我们进入字符函数和字符串函数的世界吧

字符串查找

strstr

strtok

错误信息报告

strerror

字符操作

内存操作函数

memcpy

memmove

memset

memcmp

strstr

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

Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.

#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
  char arr1[] = "abcdefbcdef";
  char arr2[] = "bcd";
  char* p = strstr(arr1, arr2);
  if (p == NULL)
  {
    printf("找不到\n");
  }
  else
  {
    printf("%s\n", p);
  }
  return 0;
}

模拟实现strstr

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
  char* s1 = NULL;
  char* s2 = NULL;
  char* cp = (char*)str1;
  while (*cp)
  {
    s1 = cp;
    s2 = (char*)str2;
    while (*s1 && *s2 && *s1 == *s2)
    {
      s1++;
      s2++;
    }
    if (*s2 == '\0')
    {
      return cp;
    }
    cp++;
  }
  return NULL;
}
int main()
{
  char arr1[] = "abcdefbcdef";
  char arr2[] = "bcd";
  char* p = my_strstr(arr1, arr2);
  if (p == NULL)
  {
    printf("找不到\n");
  }
  else
  {
    printf("%s\n", p);
  }
  return 0;
}

strtok

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

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

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

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

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

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

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

使用strtok这个函数

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
  char arr[] = "xiaoyalan@yeah.net";
  char buf[30] = { 0 };
  strcpy(buf, arr);//把字符串的内容拷贝一份
  const char* p = "@.";
  char* str = strtok(buf, p);
  printf("%s\n", str);
  str = strtok(NULL, p);
  printf("%s\n", str);
  str = strtok(NULL, p);
  printf("%s\n", str);
  return 0;
}

当然，这个代码写得不是很好，如果是有很多分隔符呢，岂不是要写很多个printf，这样，代码冗余的问题就会非常严重，那么，必然就要用到循环啦，下面，我们来改进一下这个代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
  char* p = "xiaoyalan@yeah.net";
  const char* sep = ".@";
  char arr[30];
  char* str = NULL;
  strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
  for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
  {
    printf("%s\n", str);
  }
  return 0;
}

strerror

char * strerror ( int errnum );

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
int main()
{
  char* p = strerror(0);
  printf("%s\n", p);
  p = strerror(1);
  printf("%s\n", p);
  p = strerror(2);
  printf("%s\n", p);
  p = strerror(3);
  printf("%s\n", p);
  p = strerror(4);
  printf("%s\n", p);
  p = strerror(5);
  printf("%s\n", p);
  p = strerror(6);
  printf("%s\n", p);
  return 0;
}

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
  //打开文件
  //打开文件的方式，如果文件的打开方式是“r”
  //文件存在则打开成功，文件不存在则打开失败
  //打开文件夹失败的话，会返回NULL
  FILE* pf = fopen("test.txt", "r");
  if (pf == NULL)
  {
    printf("打开文件失败，原因是:%s\n", strerror(errno));
    return 1;
  }
  //读写文件
  //......
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

另一种写法：

#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
  //打开文件
  //打开文件的方式，如果文件的打开方式是“r”
  //文件存在则打开成功，文件不存在则打开失败
  //打开文件夹失败的话，会返回NULL
  FILE* pf = fopen("test.txt", "r");
  if (pf == NULL)
  {
    perror("打开文件失败");
    return 1;
  }
  //读写文件
  //......
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

C语言的库函数在调用失败的时候，会将一个错误码存放在一个叫：errno的变量中，当我们想知道调用库函数的时候发生了什么错误信息，就可以将：errno的错误码翻译成错误信息

字符分类函数

字符转换

int tolower ( int c );
int toupper ( int c );

#include <stdio.h>
#include <ctype.h>
int main()
{
  int i = 0;
  char str[] = "Test String.\n";
  char c;
  while (str[i])
  {
    c = str[i];
    if (isupper(c))
      c = tolower(c);
    putchar(c);
    i++;
  }
  return 0;
}

memcpy

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

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

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

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

使用一下此函数：

#include<stdio.h>
#include<string.h>
void test1()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[8] = { 0 };
  //把arr1中的前5个元素拷贝到arr2中
  memcpy(arr2, arr1, 20);
}
void test2()
{
  float arr1[] = { 1.0f,2.0f,3.0f,4.0f,5.0f };
  float arr2[8] = { 0 };
  memcpy(arr2, arr1, 20);
}
int main()
{
  test1();
  test2();
  return 0;
}

模拟实现memcpy：

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
  void* ret = dest;
  assert(dest != NULL);
  assert(src != NULL);
  while (num--)
  {
    *(char*)dest = *(char*)src;
    dest = *(char*)dest + 1;
    src = *(char*)src + 1;
  }
  return ret;
}
void test3()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[8] = { 0 };
  //把arr1中的前5个元素拷贝到arr2中
  my_memcpy(arr2, arr1, 20);
}
int main()
{
  test3();
  return 0;
}

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
  void* ret = dest;
  assert(dest != NULL);
  assert(src != NULL);
  while (num--)
  {
    *(char*)dest = *(char*)src;
    dest = *(char*)dest + 1;
    src = *(char*)src + 1;
  }
  return ret;
}
void test4()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  my_memcpy(arr1+2, arr1, 40);
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
  }
}
int main()
{
  test4();
  return 0;
}

所以我们发现：在内存重叠的情况下，使用memcpy可能出现意想不到的效果

在内存重叠的情况下，使用memmove函数

memmove

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

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

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

模拟实现memmove

#include <stdio.h>
#include <string.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
  void* ret = dest;
  assert(dest != NULL);
  assert(src != NULL);
  if (dest < src)
  {
    //前->后
    while (num--)
    {
      *(char*)dest = *(char*)src;
      dest = *(char*)dest + 1;
      src = *(char*)src + 1;
    }
  }
  else
  {
    //后->前
    while (num--)
    {
      *((char*)dest + num) = *((char*)src + num);
    }
  }
  return ret;
}
void test4()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  my_memmove(arr1+2, arr1, 40);
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
  }
}
int main()
{
  test4();
  return 0;
}

memcmp

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

比较从ptr1和ptr2指针开始的num个字节

使用memcmp

#include <stdio.h>
#include <string.h>
void test5()
{
  int arr1[] = { 1,2,3,4,5 };
  //01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
  int arr2[] = { 1,2,3,4,6 };
  //01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 06 00 00 00
  int ret = memcmp(arr1, arr2, 17);
  printf("%d\n", ret);
}
int main()
{
  test5();
  return 0;
}

memset

#include <stdio.h>
#include <string.h>
void test6()
{
  int arr[10] = { 0 };
  memset(arr, 1, sizeof(arr));
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%p\n", arr[i]);
    //这种写法没办法把每个数组元素设置为1
  }
  return 0;
}
int main()
{
  test6();
  return 0;
}

好啦，小雅兰今天的内容就到这里啦，这就是字符串函数基本的内容啦，未来还要继续努力！！！

字符函数和字符串函数（下）——“C”

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

字符函数和字符串函数（下）——“C”

热门文章

最新文章

相关电子书