1.前言

字符串函数和内存函数是C语言很重要的一部分,所以在此做一个归纳希望能帮助到大家更好的理解这些函数

2.字符串函数

2.1 长度不受限制的字符串函数

2.1.1 strlen

size_t strlen(const char* str)

用来计算字符串的长度

内部细节

1. 计算字符串长度的标识是读到’\0’('\0’不包含计算长度),意思也就是计算长度是要读到\0之前
2. 函数的返回值为size_t，是无符号的整型
3. 指向的字符串必须要以’\0’ 结束 意思就是在这段字符串中在中间部分有一个\0 那么读到\0就结束

使用方法

int main()
{if (strlen("abc") - strlen("abcdef") > 0)  //string函数的返回类型是无符号整型printf(">\n");elseprintf("<\n");return 0;
}

这里输出的结果是">"就是因为strlen的返回类型是无符号的

#include<stdio.h>
#include<string.h>
int main()
{char arr1[] = "abcdef";printf("%d\n", strlen(arr1));//统计\0前的字符个数//输出结果6char arr2[10] = {'a','b','c','d','e','f'};//6//不完全初始化，其余元素默认初始化为0，printf("%d\n", strlen(arr2));//输出结果为6char arr3[] = { 'a','b','c','d','e','f' };//随机值//没有\0printf("%d\n", strlen(arr3));//输出结果是随机值
}

模拟实现

#include<assert.h>
size_t my_strlen(const char* str)
{assert(str);const char* start = str;const char* end = str;while (*end != '\0'){end++;}return end - start;
}
int main()
{char arr[] = "abcdef";int len = my_strlen(arr);printf("%d\n", len);return 0;
}

2.1.2 strcmp

int strcmp( const char *string1, const char *string2 );

用来比较对应位置上字符的大小

内部细节

1. 比较的是字符串的内容，不是字符串的长度
2. 比较内容相同则比较下一对，直到不同结束
3. 两个字符串如果第一个字符串的第一个字符大于第二字符串第第一个字符那么返回大于0的数字
4. 如果等于 那么返回等于0的数字
5. 如果小于 那么返回小于0的数字

使用方法

int main()
{char arr1[] = "abcdef";char arr2[] = "abcdeb";int ret = strcmp(arr1, arr2);if (ret > 0){printf(">");}else if (ret < 0){printf("<");}else{printf("=");}return 0;
}

这里的输出结果是">"

模拟实现

int  my_strcmp(const char* s1, const char* s2)
{assert(s1 && s2);while (*s1 == *s2){if (*s1 == '\0'){return 0;}s1++;s2++;}if (*s1 > *s2)return 1;elsereturn -1;
}
int main()
{char arr1[] = "abc";char arr2[] = "abc";int ret = my_strcmp(arr1, arr2);if (ret < 0){printf("arr1<arr2\n");}else if (ret > 0){printf("arr1>arr2\n");}elseprintf("arr1=arr2\n");return 0;
}

2.1.3 strcpy

char *strcpy( char *strDestination, const char *strSource );

用来实现字符串的拷贝

内部细节

1. 源字符串必须以’\0’ 结束。
2. 会将源字符串中的’\0’ 拷贝到目标空间然后结束
3. 目标字符串空间必须足够大，以确保能存放源字符串，否则程序会奔溃
4. 若目标空间为常量字符串，程序也会奔溃

使用方法

int main() //目标空间必须够大 确保放入源字符串
{char arr[3] = { 0 };char arr2[] = "abcdef";strcpy(arr, arr2);printf("%s\n", arr);  //崩溃return 0;
}//int main()  //目标字符串必须是可修改的
//{//  char* p = "hello world"; //常量字符串
//  char arr2[] = "abcdef";
//  strcpy(p, arr2);
//  printf("%s\n", p);  //崩溃
//  return 0;
//}

两个程序都运行不了,第一个因为空间不够大,第二个存放了常量字符串

模拟实现

char* my_strcpy(char* dest, const char* src)
{assert(dest);assert(src);char* ret = dest;while (*dest++ = *src++){;}return ret;
}
int main()
{char arr1[20] = "abc";char arr2[] = "hello bit";my_strcpy(arr1, arr2);printf("%s\n", arr1);
}

2.1.4 strcat

char *strcat( char *strDestination, const char *strSource );

字符串的追加

内部细节

1. 源字符串必须以’\0’ 结束,会以找到\0作为追加结束的条件,如果没有\0会一直寻找直到找到\0位置
2. 目标字符串的空间必须有足够的大，能容纳下源字符串的内容
3. 源字符串的\0会被一起拷贝到目标字符串中。

使用方法

int main()
{char arr1[20] = "hello\0XXXXXX";//会把源字符串的\0一起拷贝到arr1中//并且目标字符串需要有\0，arr2会追加到arr1的后面char arr2[] = "world";strcat(arr1, arr2);printf("%s\n", arr1);return 0;
}

---

strcat会在目标字符串的\0处开始拷贝，并且会把\0一起拷贝到目标字符串

模拟实现

my_strcat(char* dest, const char* src)
{//找目标空间中的\0char* cur = dest;while (*cur != '\0'){cur++;}//拷贝源头数据到\0之后的空间while (*cur++ = *src++){;}return dest;
}
int main()
{char arr1[20] = "hello ";char arr2[] = "world";my_strcat(arr1, arr2); //字符追加函数printf("%s\n", arr1);return 0;
}

---

那么能strcat给字符串自己追加吗?

//自己给自己追加 死循环
int main()
{char arr1[20] = "bit";my_strcat(arr1, arr1);return 0;
}

字符串是不可以给自己追加的,因为源字符串追加结束的标准是追加到\0但是原先\0的位置会被覆盖成目标字符串的第一个字符,那么就永远找不到\0 程序会死循环

2.1.5 strstr

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

字符串的查找

内部细节

1. 如果找到子串那么返回的是子串的首元素地址
2. 如果没找到返回的是空指针

使用方法

int main()
{char arr1[] = "abcdefg";char arr2[] = "cdef";char* ret = strstr(arr1, arr2);if (NULL == ret){printf("找不到子串\n");}else{printf("%s\n", ret);}return 0;
}

输出结果是cdef

模拟实现

char* my_strstr(const char* str1, const char* str2)
{const char* s1 = str1;const char* s2 = str2;const char* p = str1;  //p用来记录与子串可能相同的首元素位置while (*p)//当主串为0 循环结束{s1 = p;s2 = str2;while (*s1!='\0'&&*s2!="\0"&& (*s1 == *s2)){s1++;s2++;}if (*s2 == '\0') //当子串匹配到\0 证明匹配成功{return p; //找到了}p++;  //跳到下一位置,重新匹配是否与主串相同}return NULL; //找不到}
int main()
{char arr1[20] = "abcdef";char arr2[] = "bcd";char* p = my_strstr(arr1, arr2);if (p == NULL){printf("不存在\n");}else{printf("%s\n", p);}return 0;
}

2.1.6 strok

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

字符串的切分

内部细节

• strtok会把分隔符置为\0，并返回切分开字段的第一个字符的地址。
• strtok函数的第一个参数为NULL ，函数将在同一个字符串中被保存的位置(\0)开始查找下一个标记。如果字符串中不存在更多的标记，则返回NULL 指针。

使用方法

strtok
int main()
{char arr[] = "ilovecc@qqedu.com";char buf[200] = { 0 };strcpy(buf, arr);//ilovecc//qqdeu//comconst char* p = "@.";char* str = NULL;//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);for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p)){printf("%s\n", str);}return 0;
}

---

2.1.7 strerror

char * strerror ( int errnum );

获取指向错误消息字符串的指针

内部细节

1. 返回值为char * 类型
2. C语言的库函数在执行失败时，都会有一个错误码（0 1 2 3 4 5 6 7 8 9 …）
3. 当库函数调用失败,错误码记录到错误码的变量中errno ,把错误码传给strerror函数，会返回char* 类型地址，为错误信息的首元素地址，通过printf可以打印出相应错误信息

使用方法

#include<errno.h>
int main()
{printf("%s\n", strerror(0));printf("%s\n", strerror(1));printf("%s\n", strerror(2));printf("%s\n", strerror(3));printf("%s\n", strerror(4));//错误码记录到错误码的变量中 errnoFILE* pf = fopen("test.txt", "r");if(pf ==NULL){perror("cc"); //perror = printf+strerrorprintf("%d\n", errno);printf("%s\n", strerror(errno));return 1;}//读文件fclose(pf);pf = NULL;return 0;
}

---

2.2 长度受限制的字符串函数

2.2.1strncpy

char * strncpy ( char * destination, const char * source, size_t num );

复制指定长度字符到字符串

内部细节

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

使用方法

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

---

模拟实现

char* my_strncpy(char* dest, char* src, int count)
{char* start = dest;while (count && (*dest++ = *src++) != '\0') //count为0或src读到\0循环结束{count--;}if (count)//当读到\0了但指定的count还不为0 那么就把目标空间到count数字位置的全赋0{while (--count){*dest++ = '\0';}}return start;
}
int main()
{char arr1[20] = "abcdefghijk";char arr2[] = "xxxx";//my_strncpy(arr1, arr2, 3);printf("%s\n", my_strncpy(arr1, arr2, 3));return 0;
}

2.2.2strncmp

int strncmp( const char *string1, const char *string2, size_t count );

比较指定大小字符的字符串函数

内部细节

1. 比较指定个数的字符，count为字符个数
2. 两个字符串如果第一个字符串的第一个字符大于第二字符串的第一个字符那么返回大于0的数字
3. 如果等于 那么返回等于0的数字
4. 如果小于 那么小于等于0的数字

使用方法

int main()
{char arr1[] = "abcdef";char arr2[] = "abcdeg";int ret = strncmp(arr1, arr2, 2);printf("%d\n", ret);ret = strncmp(arr1, arr2, 6);printf("%d\n", ret);return 0;
}

第一个输出结果是0 第二个是-1

模拟实现

#include<assert.h>
int my_strncmp(char* str1, char* str2, size_t count)
{assert(str1 && str2);while (!((*str1 - *str2)) && *str1 && *str2 && --count)//两者相等且不为'\0'，{str1++;str2++;}return *str1 - *str2;
}
int main()
{char arr1[] = "abcd";char arr2[] = "abcc";int ret = my_strncmp(arr1, arr2, 4);if (ret > 0){printf("arr1 > arr2");}else if (ret < 0){printf("arr1 < arr2");}else{printf("arr1 = arr2");}return 0;
}

输出结果为arr1>arr2

2.2.3strncat

char * strncat ( char * destination, const char * source, size_t num );

追加指定长度字符到字符串

内部细节

1. 追加num个字符从源字符串到目标字符串的空间
2. 从目标字符串的\0位置起(包括\0)开始追加
3. !!!!如果num比源字符串长,不会在后面追加\0

使用方法

int main()
{char arr1[20] = "hello\0XXXXXXX";char arr2[] = "cc";strncat(arr1, arr2, 6);//如果操作长度大于字符串长度只会追加字符串，不会追加\0printf("%s\n", arr1);
}

---

---

//自己给自己追加 用strncat
int main()
{char arr1[20] = "abc";strncat(arr1, arr1, 3);printf("%s\n", arr1);return 0;
} 

输出结果是abcabc

模拟实现

char* my_strncat(char* dest, char* src, size_t count)
{char* start = dest;while (*dest)//找到目标字符串\0时循环停止{dest++;}while (count--){if ((*dest++ = *src++) == 0)//count长度大于源字符串，不进行补\0，直接返回return(start);}*dest = '\0';//如果没有返回，则需要在目标字符串追加完之后添上\0,此时\0return (start);
}
int main()
{char arr1[20] = "hello ";char arr2[] = "cc";char* ret = my_strncat(arr1, arr2, 5);printf("%s\n", ret);return 0;
}

3.内存函数

3.1memcpy

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

内存拷贝函数

内部细节

1. 拷贝 num个字符从源字符串到目标字符空间
2. num单位为字节
3. 可以拷贝所有的类型的数据，用void*指针
4. 函数在遇到’\0’ 的时候不会停下来，只有当元素拷贝完成后才会停下来

使用方法

int main()
{/*int arr[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };memcpy(arr2, arr, 20);*/float arr1[] = { 1.0f,2.0f,3.0f,4.0f };float arr2[5] = { 0.0 };memcpy(arr2, arr1, 8);for (int i = 0; i < 5; i++){printf("%.1f ", arr2[i]);}return 0;
}

---

模拟实现

#include<assert.h>
void* my_memcpy(void* dest, void* src, size_t num)
{void* ret = dest;//记录目标字符串首元素位置assert(dest && src);while (num--){*(char*)dest = *(char*)src; //因为num单位是字节 类型是void* 要强制转换为char* +1才能跳过一个字节dest = (char*)dest + 1;src = (char*)src + 1;}return ret;
}
int main()
{int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };my_memcpy(arr2, arr1, 20);int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr2[i]);}return 0;
}

---

经过测试 memcpy函数不可以处理同一块内存空间中的数据拷贝

因为在同一块内存中，它们使用的是相同的空间，再把arr[0]拷贝给arr[2]时候，原先arr[2]从3变成了1，所以导致arr[2]拷贝给arr[4]还是1 就变成了1212121拷贝5个字节

3.2 memmove

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

拷贝字节，目标区域和源区域有重叠也可以拷贝

内部细节

1. 和memcpy一样都是拷贝函数
2. 区别就是memove"更高端"可以拷贝重叠空间的区域
3. num的单位是字节

使用方法

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

---

模拟实现

void* my_memmove(void* dest, void* src, size_t num)
{void* ret = dest;assert(dest && src);if (dest < src)// 前->后  与memcpy一致{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;
}
int main()
{int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };int arr2[10] = { 0 };my_memmove(arr1+2, arr1, 20);int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}

---

实现memove函数有一些复杂，首先我们要考虑两种情况 一种是源串在目标串的前面(dest>src) 如果拷贝20个字节 也就是5个整型。 要将12345拷贝到34567的位置，先将1拷贝，就会将源位置的3给覆盖了导致将3拷贝时就会错误 所以当dest>src 时要从后往前拷贝 5先拷贝到7 然后4拷贝给6 ···

第二种是源串在目标串的后面(dest<src) 将34567 拷贝到12345 如果7拷贝给5 6拷贝给4 到5拷贝时就被覆盖了 所以 dest<src时要从前后往后拷贝

而当dest< src+num时 随便拷贝 是不会有重叠部分的

3.2 memcmp

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

按字节比较的函数

内部细节

1. num是字节
2. 两个字符串如果第一个字符串的第一个字符大于第二字符串第第一个字符那么返回大于0的数字
3. . 如果等于 那么返回等于0的数字
4. 如果小于 那么返回小于0的数字

使用方法

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

---

这里就要讲

模拟实现

#include<assert.h>
void* my_memcmp(const void* arr1, const void* arr2, size_t count)
{assert(arr1 != NULL && arr2 != NULL);while (count--){if (*(char*)arr1 != *(char*)arr2){return (*(char*)arr1) - (*(char*)arr2);}arr1 = (char*)arr1 + 1;arr2 = (char*)arr2 + 1;}return 0;
}
int main()
{int a[] = { 1,2,3,4,5 };int b[] = { 1,2,3,4,5,6 };int ret = my_memcmp(b, a, 21);printf("%d", ret);return 0;
}

输出结果为大于0的数字

3.2 memset

void *memset(void *s, int ch, size_t n)

始化函数 将某一块内存中的内容全部设置为指定的值

内部细节

1. n单位是字节 以字节来初始化
2. 注意ch 和 n的位置
3. 如果要把一个char a[20]清零，一定是 memset(a,0,20*sizeof(char));

使用方法

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

---

总结

字符串函数和内存函数还有很多，大家也可以去网上搜一搜自己去试着实现一下，希望我的内容能给你带来收获，谢谢大家！

C语言—字符串函数和内存函数相关推荐

1. C语言常见字符串函数、字符分类函数与内存函数的使用

   前言 C语言中对字符和字符串的处理很是频繁,但是C语言本身是没有字符串类型的,字符串通常放在 常量字符串 中或者 字符数组 中.下面介绍C语言中的一些常用的字符串函数和内存函数的功能以及实现原理. 字 ...

2. c语言字体移动函数,C语言字符函数、内存函数功能及实现代码

   C语言字符函数.内存函数 功能及实现 strlen函数(求字符串长度)注意点模拟实现 strcpy函数(字符串拷贝函数)注意点模拟实现 strcat函数(字符串衔接函数)注意点模拟实现 strcmp函 ...

3. 字符串函数以及内存函数概述

   本人能力有限,难免有叙述错误或者不详细之处!希望读者在阅读时可以反馈一下错误以及不够好的地方!感激不尽! 目录 求字符串长度: strlen 长度不受限制的字符串函数: strcpy,strcat,s ...

4. 如何求C语言字符串长度（strlen函数和sizeof关键字）

   如何求C语言字符串长度(strlen函数和sizeof关键字) 在程序里,一般会用***strlen()***函数或***sizeof()***来获取一个字符串的长度,但这2种方法获取的字符串的长度其 ...

5. C语言函数：内存函数memmove()以及实现与使用。

   C语言函数:内存函数memmove()以及实现与使用. memmove(): 头文件:#include <string.h> 函数参数:          可以发现memmove()函数的 ...

6. 字符串函数和内存函数

   目录 1.字符串函数 1.1.字符串 1.2.strlen() 1.2.1.函数介绍 1.2.2使用时要注意的一些点 1.2.3.my_strlen()的实现 1.3.strcpy() 1.3.1.函 ...

7. 字符函数和内存函数模拟实现

   字符函数和内存函数模拟实现 字符函数和内存函数模拟实现 #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<str ...

8. 【C语言笔记进阶篇】第二章：字符串函数和内存函数

   目录 (1)分类 (2)字符串函数 A:strlen(求字符串长度) B:strcpy(字符串复制_不受限制) C:strcat(字符串追加_不受限制) D:strcmp(字符串比较_不受限制) E: ...

9. C语言字符串函数，内存函数讲解及其模拟

   在这篇博客会讲解以下函数:strlen,strcpy,strcat,strcmp,strncpy,strncat,strncmp,strstr,strtok,memcpy,memmove,memset ...

最新文章

1. 【微信小程序企业级开发教程】视图与渲染详解
2. linux——vim命令详细说明
3. #地形剖面图_高中地理——每日讲1题（地形剖面图、河流水的补给、河流丁坝）...
4. 依弗科（上海）机电设备有限公司
5. 不同符号的两个整数求余和取模的计算技巧（规律）
6. 深入理解java内置锁(synchronized)和显式锁(ReentrantLock)
7. htmlh1 h6,HTML 5 h1 至 h6 标签 - HTML 参考手册
8. 易达园林注册机_科创易达园林绿化插件免费版
9. 用户坐标系和工具坐标系校准原理
10. 华为手机Root方法（推荐）
11. 为什么没什么人玩呢？凰华学院主校剧情有感
12. sql中exist与in 的区别
13. 王国维先生的“人生三大境界”
14. co作为前缀的意思_卡西欧G-SHOCK型号解析大全 看懂前缀的字母 省的被忽悠
15. hdu1002 a+bII 大数相加
16. 外行假装内行，我也来谈谈SAP BAPI和BADI
17. 基于jsp(java)财务管理系统的设计和开发
18. java发送 NameValuePair格式post请求
19. plsql和navicate有什么区别_plsql和navicat连接远程oracle（易错点）
20. 使用c语言求一元二次方程的根

热门文章

1. 【单片机仿真】（七）寻址方式 — 位寻址
2. P2P分布式搜索引擎YaCy
3. 【现代通信原理笔记】8 蜂窝系统
4. java的常量和变量_JAVA-常量和变量
5. 2惠普暗影精灵恢复出厂设置
6. GrapeCity Documents for Imaging
7. 使用 Sqoop 将 30W+ MySQL 数据导入 Hive
8. git clone下载代码，解决中途断开下载的方法
9. 关于linux fc多路径巡检
10. PHP在线发信投稿系统网站程序