目录
求字符串长度
strlen
长度不受限制的字符串函数
strcpy
strcat
strcmp
长度受限制的字符串函数
strncpy
strncat
strncmp
字符串查找
strstr
strtok
错误信息报告
strerror
内存操作函数
C语言中对字符和字符串的处理很频繁，但是由于C语言本身是没有字符串类型，
字符串类型通常放在**常量字符串**或者**字符数组**中
函数介绍
求字符串长度
strlen
1. 字符串中存在‘\0'作为结束标志，strlen函数返回的是在字符串中'\0'
前面出现的字符个数（不包含'\0')
2.参数指向的字符串必须以'\0'作为结束标志
3.注意函数的返回值为size_t,是无符号的
strlen函数的模拟实现
#include<stdio.h>
int main()
{
char arr[] = "hello crush";
int ret = my_strlen(arr);
printf("%d\n", ret);
return 0;
}
方法1：计数器方式
size_t my_strlen(char* str)
{
int count = 0;
while (*str)
{
count++;
str++;
}
return count;
}
方法2：不创建临时变量的计数器->递归
size_t my_strlen(char* str)
{
if (*str == '\0')
{
return 0;
}
else
{
return 1 + my_strlen(str + 1);
}
}
方法3：指针-指针
指针-指针计算结果是中间元素的个数
size_t my_strlen(char* str)
{
char* p = str;
while (*str)
{
str++;
}
return str - p;
}
长度不受限制的字符串函数
strcpy-字符串拷贝
1. 将源字符串复制到目标空间中（包含'\0')
2. 源字符串必须以'\0'作为结束标志
3. 目标空间必须足够大，以确保能存放源字符串
4. 目标空间必须足够大
模拟实现strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[] = "hello crush";
char arr2[20] = "xxxxxxxxxxxxxxxxx";
char* ret = my_strcpy(arr2, arr1);
printf("%s\n", arr2);
return 0;
}
strcat-字符串追加
1. 将源字符串追加到目标字符串中，目标字符串中的终止字符被源字符串
的第一个字符覆盖。
2.源字符串必须以'\0'作为结束标志
3.目标空间必须足够大，能够容纳源字符串的内容
4.目标空间必须可修改
模拟实现strcat
1.找到目标字符串结尾的'\0'
2.拷贝—strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
//1.找到目标字符串结尾的'\0'
while (*dest)
{
dest++;
}
//模拟strcpy函数
//2.拷贝—strcpy
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = "hello ";
char arr2[] = "crush";
char* ret = my_strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
strcmp-字符串比较
1.函数开始比较每个字符串的第一个字符,如果它们彼此相等，
则继续执行以下对，直到字符不同或到达终止空字符为止。
2.标准规定
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现strcmp
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1 == *str2)
{
if (*str1 == '\0')
{
return 0;
}
str1++;
str2++;
}
return *str1 - *str2;
}
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdef";
int ret = my_strcmp(arr1, arr2);
if (ret == 0)
{
printf("arr1==arr2");
}
else if (ret < 0)
{
printf("arr1<arr2");
}
else
{
printf("arr1>arr2");
}
return 0;
}
长度受限制的字符串函数
strncpy-长度受限的字符串拷贝
1。从源字符串中拷贝num个字符到目标空间
2.如果源字符串的长度小于num，则拷贝完源字符串之后，在目标空间后面追加'\0'，直到num个字符
代码演示
#include<stdio.h>
int main()
{
char ch1[] = "hello";
char ch2[10] = "*********";
strncpy(ch2, ch1, 8);
printf("%s\n", ch2);
return 0;
}
strncat-长度受限的字符串追加
1.将源字符串的第num个字符追加到目标空间中，再加上'\0'作为终止
2.如果源字符串的长度小于num，则只追加到包括'\0'的内容
#include<stdio.h>
#include<string.h>
int main()
{
char ch1[20] = "hello\0********";
char ch2[] = "crushabcdef";
strncat(ch1, ch2, 5);
return 0;
}
strncmp-长度受限的字符串比较
1.将字符串str1中最多num个字符与字符串str2中的最多num个字符进行比较。
2.开始比较每个字符串的第一个字符，如果它们彼此相等，它将继续执行以下对，
直到字符不同，直到到达终止空字符。或者直到num个字符在两个字符串中匹配（以先发生者为准）。
字符串查找
strstr
返回指向str2在str1中的第一次出现的指针，
如果str2不属于str1，则返回空指针
模拟实现strstr
#include<stdio.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
//const修饰的变量一般不进行修改
//创建临时变量s1,s2
const char* s1 = str1;
const char* s2 = str2;
char* p = s1;
while (*p)
{
s2 = str2;
s1 = p;
while (*s1 == *s2 && *s1 != '\0' && *s1 != '\0')
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return p;
}
p++;
}
return NULL;
}
int main()
{
char arr1[] = "abbcdef";
char arr2[] = "bcd";
char* ret = my_strstr(arr1, arr2);
if (ret == NULL)
{
printf("字串不存在\n");
}
else
{
printf("%s\n", ret);
}
return 0;
}
strtok
1.del参数是字符串，定义了用作分隔符的字符集合
2.第一个参数指定一个字符串，它包含0个或者多个由del字符集合
中一个或者多个分隔符的标记
3.strtok函数找到str中的第一个标记，并将其用'\0'结尾，
返回一个指向这个标记的指针（strtok函数会改变被操作的字符串，
在使用strtok函数切分的字符串一般都是临时拷贝的内容
4.strtok函数的一个参数不为NULL，函数将找到str中第一个标记，strtok
函数将保存它在字符串中的位置
5.strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置
开始，查找下一个标记
6.如果字符串中不存在更多的标记，则返回NULL指针
strtok函数的使用
#include<stdio.h>
#include<string.h>
int main()
{
const char* del = "@.";
char arr[] = "2841460969@qq.com";
char ch[20] = { 0 };
strcpy(ch, arr);
char* ret = NULL;
for (ret = strtok(ch, del); ret != NULL; ret = strtok(NULL, del))
{
printf("%s\n", ret);
}
return 0;
}
错误信息报告
strerror
返回错误码所对应的错误信息
C语言的库函数，在执行失败时都会设置相应的错误码
例如
#include<stdio.h>
#include<string.h>
int main()
{
printf("%s\n", strerror(0));
printf("%s\n", strerror(1));
printf("%s\n", strerror(2));
printf("%s\n", strerror(3));
return 0;
}
实例
errno是C语言设置的全局的错误码存放的变量
#include<stdio.h>
#include<string.h>
#include<errno.h>
int main()
{
FILE* p = fopen("test.c", "r");
if (p == NULL)
{
printf("%s\n", strerror(errno));
}
return 0;
}
由运行结果可知，文件test.c存在
内存操作函数
memcpy-内存拷贝
1.函数memcpy从source的位置开始向后复制num个字节的数据到destination
的内存位置
2.函数在遇到'\0'时并不会停下来
3.如果source和destination有任何的重叠，复制的结果都是未知的
模拟实现memcpy
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, int num)
{
assert(dest && src);
void* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9 };
int arr2[10] = { 0 };
my_memcpy(arr2, arr1, 20);
return 0;
}
memmove-可处理重叠的内存拷贝
1.与memcpy的差别是memmove函数处理的源内存块和目标内存块是可以重叠的
2.如果源空间和目标空间出现重叠，需要使用memmove函数进行处理
模拟实现memmove函数
当dest<src时，情况1 需要从前往后拷贝数据
当src<dest<src+size_num 情况2 从后往前或者从前往后均可拷贝
当src+size_num<dest 情况3 需要从后往前拷贝数据
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, int num)
{
assert(dest && src);
void* ret = dest;
//从前往后拷贝
if (dest < src)
{
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
//从后往前拷贝
else
{
while (num--)
{
*((char*)dest + num) = *((char*)src + num);
}
}
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
int sz = sizeof(arr) / sizeof(arr[0]);
my_memmove(arr + 2, arr, 20);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
memcmp-内存数据比较
1.比较从ptr1和ptr2只在开始的第num个字节
2.若ptr1指向的字节内容比ptr2指向的字节内容小，返回小于0的变量
若ptr1指向的字节内容和ptr2指向的字节内容相等，则继续向后比较
若ptr1指向的字节内容比ptr2指向的字节内容大，返回大于0的变量
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
