C语言字符串函数,字符函数,内存操作函数

char arr[]="abc\0def";
int len=strlen(arr);
printf("%d\n",len);  //3

char arr[3] = { 'a','b','c' };
  int len = strlen(arr);
  printf("%d\n", len);   //随机值

const char* str1 = "abcdef";
  const char* str2 = "bcd";
  if (strlen(str2) - strlen(str1) > 0) {
    printf("str2>str1\n");
  }
  else {
    printf("str2<str1\n");
  }
  return 0;

//1.计数器
#include<assert.h>
#include<stdio.h>
#include<string.h>
//这里将my_strlen自定义函数的返回类型定义为int,当遇到strlen("abdcf")-strlen("shfudgfu")这种情况计算结果时不容易出错
int my_strlen(const char* str) {  //求长度时只需要遍历字符串,不需要修改它,所以用const来保护指针所指向的内容
  int count = 0;
  assert(str);  //担心str是空指针,用assert()来断言一下str是不是空指针,保证指针的有效性
  while (*str != '\0') {
    count++;
    str++;
  }
  return count;
}
int main() {
  char arr[] = "bit";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}

int my_strlen(const char* str) {
  if (*str != '\0')
  {
    return 1 + my_strlen(str+1);
  }
  else {
    return 0;
  }
}
int main() {
  char arr[] = "bit";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}

int my_strlen(char* s) {
  char* p = s;
  while (*p != '\0') {
    p++;
  }
  return p - s;
}
int main() {
  char arr[] = "bit";
  int len = my_strlen(arr);
  printf("%d\n", len);
  return 0;
}

#include<stdio.h>
#include<string.h>
int main() {
  char arr1[] = "abcdef";
  char arr2[20] = {0};
  strcpy(arr2, arr1);
  printf("%s\n", arr2);
  return 0;
}

int main() {
  char* p = "abcdefghi";  //p指向的是常量字符串,不能被修改
  char arr2[20] = "hehe";
  strcpy(p, arr2);
  printf("%s\n", p);
  return 0;
}

#include<assert.h>
char* my_strcpy(char* dest, const char* src) {
  char* ret = dest;         //在最开始的时候把目的地址保存起来
  assert(dest && src);  //断言保证这两个指针的有效性
  while (*dest++ == *src++) {       // \0的ASCII值是0,就不执行*dest=*src这条指令了
    ;
  }
  return ret;
}
int main() {
  char arr1[] ="hehe";
  char arr2[20] = {0}; 
  my_strcpy(arr2,arr1);
  printf("%s\n", arr2); //printf("%s\n", my_strcpy(arr2,arr1););
  return 0;
}

int main()
{
  char arr1[20] = "hello";
  char arr2[] = "world";
  strcat(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}

#include<assert.h>
char* my_strcat(char* dest, const char* src) {
  assert(dest && src);        //assert断言保证两个指针的有效性
  char* ret = dest;     //最开始把目的地址保存起来
  while (*dest != '\0') {
    dest++;
  }
  while (*dest++ = *src++) {  //拷贝
    ;
  }
  return ret;
}

int main() {
  char arr1[20] = "hello";
  char arr2[] = "world";
  my_strcat(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}

int main() {
  char arr1[20] = "bit";
  my_strcat(arr1, arr1);
  printf("%s\n", arr1);
  return 0;
}  //error

#include<assert.h>
int my_strcmp(const char* str1, const char* str2) {
  assert(str1&&str2); //保证两个指针非空
  while (*str1 == *str2) {    //2个字符串相等的情况在while循环里面
    if (*str1 == '\0') {
      return 0;
    }
    str1++;
    str2++;
  }
  if (*str1 > *str2)
    return 1;
  else
    return -1;
  //上面的if...else...太啰嗦,可以改为return *str1-*str2;
}
int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "acdf";
  int ret = my_strcmp(arr1, arr2);
  printf("%d\n", ret);
  return 0;
}

int main() {
  char arr1[] = "abcdef";
  char arr2[20] = "xxxx";
  strncpy(arr2, arr1, 3);
  printf("%s\n", arr2);
  return 0;
}

int main() {
  char arr1[20] = "hello";
  char arr2[] = "abcdef";
  strncat(arr1, arr2, 3);//将arr2中的3个字符追加到arr1后面
  printf("%s\n", arr1);
  return 0;
}

int main() {
  char arr1[20] = "hello \0xxxxxxxx";
  char arr2[] = "abcdef";
  strncat(arr1, arr2, 8); 
  printf("%s\n", arr1);
  return 0;
}

int main(){
  char arr1[] = "abcdef";
  char arr2[] = "bcd";
  char* p = strstr(arr1, arr2);
  if (p == NULL) {
    printf("找不到\n");
  }
  else {
    printf("%s\n", p);
  }
  return 0;
}

char* my_strstr(const char* str1, const char* str2) { //在查找的过程中不会修改str1,str2字符串,用const保护起来
  char* s1 = NULL;//用来维护遍历第一个字符串
  char* s2 = NULL;//用来维护遍历第二个字符串
  char* cp = (char*)str1;  //cp用来记录每次开始匹配的位置
              //str1是const修饰的指针`,是一个相对安全的指针.cp是char*类型,将相对安全的指针交给不安全的指针,权限被放大,编译器报警告,因此这里需要将str1进行强制类型转换一下
  while (*cp) {   //*cp指向被遍历的串,当*cp不是\0说明这个串还没完
    s1 = cp;    //将开始匹配的位置交给s1,让s1从这里开始遍历
    s2 = (char*)str2; //将arr2的起始地址交给s2;str2这里也需要进行强制类型转换
    while (*s1 && *s2 && *s1 == *s2) {//当*s1指向\0会停下来,*s2指向\0也会停下来
                     //s1,s2指向的内容相等那么遍历指针同时++
      s1++;
      s2++;
    }
    if (*s2 == '\0') {    //当*s2指向\0说明子串匹配完
      return cp;      //返回最开始匹配的位置
    }
    cp++; //s1内容和s2内容不相等,说明当前位置匹配是失败的,cp++,从下一个位置再开始匹配
  }
  //上面的循环结束说明第一个字符串里面的字符全都匹配了一遍也没有找到第二个字符串,那么此时结果就是找不到
  return NULL;    //如果在循环中始终没有找到子串,没有返回cp,return空指针说明找不到
}
int main() {
  char arr1[] = "abcdef";
  char arr2[] = "bcd";
  char* p = my_strstr(arr1, arr2);
  if (p == NULL) {
    printf("找不到\n");
  }
  else {
    printf("%s\n", p);
  }
  return 0;
}

int main() {
  char  arr[] = "zhuimin@yeah.net";
  char buf[30] = { 0 };
  strcpy(buf, arr);  //拷贝一份
  const char* p = "@."; //标记符集合的字符串
  char* str = strtok(buf, p);        //第一次分割:在buf中找到p中的第一个标记符,将其修改为\0,保存并记住这个标记符的位置,函数返回标记段的起始位置
  printf("%s\n", str);
  str = strtok(NULL, p);       //第二次分割:strtok从第一次切割时保存的标记符位置处查找下一个标记
  printf("%s\n", str);
  str = strtok(NULL, p);      //第三次分割:strtok从第二次分割后保存的位置处查找下一个标记,发现此时字符串中没有更多的标记,结果返回空指针
  printf("%s\n", str);
  return 0;
}

int main() {
  char  arr[] = "zhuimin@yeah.net";
  char buf[30] = { 0 };
  strcpy(buf, arr);  //拷贝一份
  const char* p = "@."; //标记符集合的字符串
  char* str = NULL;
  for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p)) {
    printf("%s\n", str);
  }
  return 0;
}

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);
  return 0;
}

int main() {
  //打开文件
  //打开文件的时候,如果文件的打开方式是"r"  (读)
  //文件存在则打开成功,文件不存在则打开失败
  //打开失败的时候,会返回NULL
  FILE* pf = fopen("text.txt", "r");
  if (pf == NULL) {
    printf("打开文件失败,原因是%s\n", strerror(errno));
    return 1;
  }
  //读写文件
  //....
  //关闭文件
  fclose(pf);
  pf = NULL;
  return 0;
}

#include<stdio.h>
#include<ctype.h>
void test() {
  char arr[120] = { 0 };
  gets(arr);
  int i = 0;
  while (arr[i]){
    if (isupper(arr[i])) {
      arr[i] = tolower(arr[i]);
  }
    printf("%c", arr[i]);
    i++;
    }
}
int main() {
  test();
  return 0;
}

void test1() {
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[8] = { 0 };
  //将arr1中的前五个元素拷贝到arr2中
  //元素类型是int类型,五个元素总共是20字节
  memcpy(arr2, arr1, 20);
  int i = 0;
  while (arr2[i]){
    printf("%d ",arr2[i]);
    i++;
    }
}
int main() {
  test1();
  return 0;
}

void test2() {
  float arr1[] = { 1.0f,2.0f,3.0f,4.0f,5.0f,6.0f,7.0f,8.0f,9.0f,10.0f };
  float arr2[8] = { 0 };
  //将arr1中的前3个元素拷贝到arr2中
  memcpy(arr2, arr1, 12);
  int i = 0;
  while (arr2[i]){
    printf("%f ",arr2[i]);
    i++;
    }
}
int main() {
  test2();
  return 0;
}

#include<assert.h>
void* my_memcpy(void* dst, const void* src, size_t count)
{
  void* ret = dst;  //临时变量保存dst地址
  assert(dst && src);  //断言两个指针不能为空指针
  while (count--) {   //每次处理一个字节,将指针强制类型转换成char*
    *(char*)dst = *(char*)src;  //一个字节一个字节的拷贝(注意:强制类型转换是临时的,转换完解引用dst还是void*类型
    dst = (char*)dst + 1;  //跳过一个字节后的地址给dst,dst是void类型,可以接收
    src = (char*)src + 1;
  }
  return ret;
}

#include<assert.h>
void* my_memcpy(void* dst, const void* src, size_t count)
{
  void* ret = dst;  //临时变量保存dst地址
  assert(dst && src);  //断言两个指针不能为空指针
  while (count--) {   //每次处理一个字节,将指针强制类型转换成char*
    *(char*)dst = *(char*)src;  //一个字节一个字节的拷贝(注意:强制类型转换是临时的,转换完解引用dst还是void*类型
    dst = (char*)dst + 1;  //跳过一个字节后的地址给dst,dst是void类型,可以接收
    src = (char*)src + 1;
  }
  return ret;
}
void test3() {
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  my_memcpy(arr1 + 2, arr1, 20);  //想要把1,2,3,4,5拷贝到3,4,5,6,7的位置
  int i = 0; for (i = 0; i < 10; i++) {
    printf("%d ", arr1[i]);
  }
}
int main() {
  test3();
  return 0;
}

void my_memmove(void* dst,void* src,size_t num) {
  void* ret = dst;
  assert(dst && src);
  if (dst < src) {  //从前往后拷贝
    while (num--) {
      *(char*)dst = *(char*)src;
      dst = (char*)dst+1;
      src = (char*)src+1;
    }
  }
  else {      //从后往前拷贝
    while (num--) {
      *((char*)dst + num) = *((char*)src + num);
    }
  }
  return ret;
}

void test5() {
  int arr1[] = { 1,2,3,4,5 };
  int arr2[] = { 1,2,3,4,6 };
  int ret1 = memcmp(arr1, arr2, 16);
  int ret2 = memcmp(arr1, arr2, 17);
  printf("%d\n", ret1);
  printf("%d\n", ret2);
}
int main() {
  test5();
  return 0;
}

//将hello改为xxxxx
void* test6() {
  char arr[] = "hello world";
  memset(arr, 'x', 5);
  printf("%s\n", arr);
}
int main() {
  test6();
  return 0;
}

//将数组的10个元素全改为1
void* test7() {
  int arr[10] = { 0 };
  memset(arr, 1, sizeof(arr));
  int i = 0;
  for (i = 0; i < 10; i++) {
    printf("%s\n", arr[i]);
  }
}
int main() {
  test7();
  return 0;
}