文章目录
一、前言
在C语言中，只有字符类型，并没有字符串类型，字符串通常需要放在数组或是以常量字符串表示。
我们很多时候需要对字符串进行操作，因此就有了很多相关的操作函数，接下来我们一 一介绍，并且通过自己的方式实现它们中的一些。
二、认识函数及其实现
以下大多数函数都属于string.h库。
1.实现strlen的三种方法
strlen是用来计算字符串长度的函数，指针遇到\0停止，要想实现它很简单。
size_t 是unsigned int。
#include<stdio.h>
#include<assert.h>
//方法1 变量
size_t my_strlen1(const char* p)
{
assert(p);
size_t count = 0;
while (*p != '\0')
{
p++;
count++;
}
return count;
}
//方法2 递归
size_t my_strlen2(const char* p)
{
assert(p);
if (*(p++) == '\0')
{
return 0;
}
return my_strlen2(p) + 1;
}
//方法3 指针
size_t my_strlen3(const char* p)
{
assert(p);
const char* ret = p;
while (*p != '\0')
{
p++;
}
return p - ret;
}
int main()
{
char arr[] = "abcdef";
size_t len = my_strlen1(arr);
printf("%u\n", len);//6
len = my_strlen2(arr);
printf("%u\n", len);//6
len = my_strlen3(arr);
printf("%u\n", len);//6
return 0;
}
2.strcpy和strncpy
strcpy是字符串拷贝，而strncpy多个n就对拷贝的数量进行了限定。
- 函数将source指针指向的字符串拷贝至destination指针指向的空间。
- source指针遇到\0停止
- 在strncpy中，如果source指针指向的空间字符数小于num个，那么在拷贝完在最后需要加上\0。
strcpy的实现
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* des, const char* src)
{
assert(des && src);
char* ret = des;
while (*des++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[] = "abcdef";
char arr2[20] = { 0 };
my_strcpy(arr2, arr1);
printf("%s\n", arr2);
return 0;
}
strncpy的实现
#include<stdio.h>
#include<assert.h>
char* my_strncpy(char* des, const char* src, int count)
{
assert(des && src);
char* ret = des;
while (count--)
{
*des++ = *src++;
}
*des = '\0';
return ret;
}
int main()
{
char str1[] = "ab";
char str2[] = "cdd";
my_strncpy(str2, str1, 3);
printf("%s\n", str2);
return 0;
}
3.strcmp和strncmp
字符比较函数是字符串唯一一种比较的方式。
比较规则
- 第一个字符串大于第二个字符串，则返回大于0的数字
- 第一个字符串等于第二个字符串，则返回0
- 第一个字符串小于第二个字符串，则返回小于0的数字
- strncmp与strcmp不同就是能限量比较。
- 字符的比较依靠的是ASCII码的大小。
- 字符串大小由从头到尾的顺序中单个字符的大小决定，如abc abd，前面相同 c<d 说明第一个字符串小于第二个字符串
int my_strcmp(const char* src, const char* dst)
{
assert(src && dst);
while (*src == *dst)
{
if (*src == '\0')
{
return 0;
}
src++;
dst++;
}
if (*src > *dst)
{
return 1;
}
return -1;
}
int my_strncmp(const char* src, const char* dst, int num)
{
assert(src && dst);
while (num--)
{
if (*src == *dst)
{
src++;
dst++;
}
else if (*src > *dst)
{
return 1;
}
else if (*src < *dst)
{
return -1;
}
}
return 0;
}
int main()
{
char* str1 = "abcfff";
char* str2 = "abcfef";
int ret = my_strcmp(str1,str2);
printf("%d\n", ret);
ret = my_strncmp(str1, str2, 4);
printf("%d\n", ret);
}
4.strcat和strncat
strcat的作用是将source指向的字符串拼接再destination指向的字符串尾部。
而strncat则是限定了source拼接在目标字符串尾部的字符数。
- 目标空间处必须有足够的空间储存拼接后的字符串
- 目标空间可更改并且以\0结尾
strcat的实现
char* my_strcat(char* des, const char* src)
{
assert(des && src);
char* ret = des;
while (*des != '\0')
{
des++;
}
while (*des++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[10] = "abc";
char arr2[] = "def";
my_strcat(arr1, arr2);
printf("%s\n", arr1);//abcdef
return 0;
}
strncat的实现
char* my_strncat(char* des, char* src, int count)
{
assert(des && src);
char* ret = des;
while (*des)
{
des++;
}
while (count--)
{
(*des) = (*src);
des++;
src++;
}
*des = '\0';
return ret;
}
int main()
{
char str1[10] = "ab";
char str2[10] = "cdd";
my_strncat(str1,str2,2);//abcd
printf("%s\n", str1);
return 0;
}
5.strtok和strstr
strstr的功能是字符串匹配。
下面是两种函数声明的写法，在str1中匹配str2一样的字符串，如果匹配成功返回str2，如果不存在返回NULL。
在strstr函数实现当中有两种算法，第一种叫做KF算法（也是暴力求解的算法），另一种效率高但复杂的算法叫做KMP算法（这里就不再讨论，有关可看KMP算法）。
在这里我们用KF算法解决。
char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
const char* s1 = str1;
const char* s2 = str2;
const char* p = str1;
while (*p)
{
while (*s1 == *s2 && *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return (char*)p;
}
s2 = str2;
s1 = ++p;
}
return NULL;
}
int main()
{
char arr1[] = "bc";
char arr2[] = "bbc";
char* ret = my_strstr(arr1, arr2);
if (ret)
{
printf("找到了");
}
else
{
printf("没找到");
}
return 0;
}
strtok
char * strtok ( char * str, const char * sep );
strtok作用是通过分隔符分割字符串。
- sep参数代表字符串，指向一个分隔符的集合。
- 第一个参数是一个字符串，它包含了0个或多个由分割符分割的标记。
- strtok将会找到下一个标记，并用\0结尾，返回一个指向这个标记的指针。
(strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。） - strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回 NULL 指针。
int main()
{
const char* sep = "@.";
char email[] = "xxxxxxx@qq.com";
char cp[50] = "\0";
strcpy(cp, email);
//char* ret=strtok(cp, sep);
//printf("%s\n", ret);
//ret = strtok(NULL, sep);
//printf("%s\n", ret);
//ret = strtok(NULL, sep);
//printf("%s\n", ret);
//第二种打印方式
for (char* ret = strtok(cp, sep); ret!=NULL; ret = strtok(NULL, sep))
{
printf("%s\n", ret);
}
/*打印结果
xxxxxxx
qq
com
*/
}
6.strerror和memset
char * strerror ( int errnum );
strerror能提供给我们各种错误码，如 0-10
但我们对于错误码和错误信息的对应并不熟悉，所以通过
strerror(error)，在出错的时候就会显示出相应的错误信息。
例如
void test()
{
int i = 0;
int* p = (int*)malloc(INT_MAX); //开辟空间过大 导致开辟失败
if (NULL == p)
{
printf("%s\n", strerror(errno));//打印 Not enough space
exit(1);
}
free(p);
}
int main()
{
test();
return 0;
}
memset
void *memset(void *str, int c, size_t n)
memset通过访问指针str，在起始位置往后的n个字节里，都初始化为c。
比如
int main()
{
char arr[] = "hello world";
memset(arr, 'x', 4); //从首地址h开始,向后4个字节都修改为x（x的ASCII码对应int型）
printf("%s\n", arr); //xxxxo world
return 0;
}
但值得注意的是 memset对应的是一个字节的修改
例如
int main()
{
int arr[] = {1,2,3,4,5,6,7};
memset(arr, 0, 4); //从首地址开始修改4个字节 01 00 00 00 -> 00 00 00 00
for(int i=0;i<7;i++)
printf("%d ", arr[i]);//0 2 3 4 5 6 7
return 0;
}
7.memcpy和memmove
在之前两个字符拷贝函数（strcpy和strncpy），它们只能对字符进行操作，而memcpy是在内存中以字节为单位进行拷贝，所以不只对字符操作。
- 用void是为了接收不同类型的指针，void指针不能进行解引用和计算，所以在函数操作这些指针时，需要类型转换。
- memcpy函数在遇到 ‘\0’ 的时候并不会停下来，它的拷贝进度只依据参数num进行。
void* my_memcpy(void* des, const void* src, size_t num)
{
assert(des && src);
void* ret = des;
while (num--)
{
*(char*)des = *(char*)src;
((char*)des)++;
((char*)src)++;
}
return ret;
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,0 };
int arr2[10] = {0};
my_memcpy(arr2, arr1, 20);//拷贝5个int类型(20个字节)
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr2[i]);//1 2 3 4 5 0 0 0 0 0
}
printf("\n");
return 0;
}
但是我们这里实现的memcpy，如果对于重叠的复制，那么有很大的缺陷的。
如：
int main()
{
int arr1[] = { 1,2,3,4,5,6,7,8,9,0 };
my_memcpy(arr1 + 2, arr1, 20);
//我们想要的结果是 1 2 1 2 3 4 5 8 9 0
int i = 0;
for (i = 0; i < 10; i++)
{
//但结果是 1 2 1 2 1 2 1 8 9 0
printf("%d ", arr1[i]);
}
printf("\n");
return 0;
}
我们很快发现了问题的所在，在arr1指针调用的时候，原本的位置已经被1或者2给覆盖了。
那么如何解决这个问题呢？ memmove的实现很有效的解决了这个问题。
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理。
void* my_memmove(void* des, const void* src, int count)
{
assert(des && src);
if (src > des)
{
//前->后
while (count--)
{
*(char*)des = *(char*)src;
((char*)des)++;
((char*)src)++;
}
}
else
{
//后->前
while (count--)
{
*((char*)des+count) = *((char*)src+count);
}
}
return des;
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
my_memmove(arr + 2, arr, 20);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);//1 2 1 2 3 4 5 8 9 0
}
return 0;
}
8.memcmp和atoi
memcmp从名字中可推断出，它是在内存中通过字节进行比较。
它的比较规则和strcmp一样。
int my_memcmp(const void* src, const void* dst, size_t count)
{
assert(src && dst);
int ret = 0;
while (! (ret = (*(char*)src) - (*(char*)dst)) && count--)
{
((char*)src)++;
((char*)dst)++;
}
if (ret > 0)
{
return 1;
}
else if (ret < 0)
{
return -1;
}
return ret;
}
int main()
{
int arr1[10] = { 1,2,3,4,5 };
int arr2[10] = { 1,3 };
int ret = my_memcmp(arr1, arr2, 12);
printf("%d\n", ret); //-1
return 0;
}
atoi
atoi函数通过将字符串中的数字转换成整型进行返回。
跳过空格，当遇到非数字时，直接返回。
int my_atoi(const char* str)
{
assert(str);
while (isspace(*str))
{
str++;
}
int flag = 0;
if (*str == '-')
{
str++;
flag = -1;
}
if (*str == '+')
{
str++;
flag = 1;
}
long long ret = 0;
while ('0' <= *str && *str <= '9')
{
ret = ((*str - '0') + ret * 10);
if (ret > INT_MAX || ret < INT_MIN)
{
return 0;
}
str++;
}
ret=(flag == -1) ? (-ret) : ret;
return (int)ret;
}
int main()
{
int val;
char str[100];
strcpy(str, " -123gds23");
val = my_atoi(str);
printf("字符串值 = %s, 整型值 = %d\n", str, val);
return(0);
}
扫一扫
1223
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
