常见的字符串操作函数详解

最新推荐文章于 2024-05-02 14:39:06 发布

2023框框

最新推荐文章于 2024-05-02 14:39:06 发布

阅读量1.1k

点赞数 1

分类专栏： c语言文章标签： c语言

本文链接：https://blog.csdn.net/weixin_58004346/article/details/120351668

版权

c语言专栏收录该内容

21 篇文章 0 订阅

订阅专栏

文章目录

字符串操作函数实现详解

字符串操作函数实现详解

一、模拟实现strlen函数

1.strlen原型

size_t strlen(const char*string);

2.strlen功能

函数的功能：求一个字符串的长度

3.strlen 实现的方法和思路

我们只要有一个指针指向这个字符串的起始位置，让它一直往后走，直到遇到**\0**；

指针每走一次，变量count++，count是用来统计字符串的长度，

如果字符串没有\0,那么这个指针越过了字符串然后继续找，直到遇到\0，所以这个结果是不确定的比如这个字符串

char arr[5]={'1','2','2','4','5'};

如果用sizeof求字符串长度，sizeof返回的是变量声明后所占的内存数，不是实际的长度，此外sizeof不是函数而是一个操作符

字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
参数指向的字符串必须要以 ‘\0’ 结束。
注意函数的返回值为size_t，是无符号的（易错）

代码实现；

A.暴力求解

#include<stdio.h>
#include<stdio.h>
#include<assert.h>
#define NUM 10
size_t my_strlen(const char  *arr)
{
    size_t count = 0;
    assert(arr != NULL); // 如果arr地址是空地址，则报错
    while (*arr)
    {
        count++;
        arr++;
    }
    return count;
}

int main()
{
    const char arr[NUM] = "ab cdf";// 不能改变数组的内容    
    unsigned  int len = my_strlen(arr);
    printf("%u",len);  // 输出结果为6 ， 因为字符串末尾隐藏了\0 ,\0的ASCII是0， 而空格的码值为32
  
    return 0;
}

B.递归方法

//用递归的方法实现strlen
#include<stdio.h>
int my_strlen(char* arr)
{
	//递归结束条件
	if (*arr)
	{
		return 1 + my_strlen(++arr);
	}
	else {
		return 0;
	}
}
int main()
{
	char arr[] = "abcdef";
	int ret=my_strlen(arr);
	printf("%d", ret);

	return 0;
 }

C.指针—指针

指针减指针求出的是指针之间的元素个数

#include<stdio.h>

int my_strlen(char* arr)
{
	char* start = arr;
	char* end = arr;
	while (*end)
	{
	    
		end++;
	}
	return end - start;
}
int main()
{
	char arr[] = "abcdef";
	int ret = my_strlen(arr);
	printf("%d", ret);
	return 0;
}

二、模拟实现strcpy（）

1.函数原型

char * strcpy(char*destination,const char * Str);

2.函数的功能

将str 里的内容拷贝到dest里，\0也要，strcpy要拷贝到\0才会停止拷贝；所以一定要确保目标空间足够大。

源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。

3.strcpy的实现

include<stdio.h>
#include<assert.h>

char* my_strcpy(char* pa,const char* pb)
{
	assert(pa && pb);//   断言 - 判断传参过来是不是空指针，如果是空指针则报错
	char* ret = pa;                //  一样 assert(pa!=NULL&&pb!=NULL);
	while (*pa++ = *pb++)//遇到\0 后停止循环
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[] = "abcdef";// [a b c d e f \0]
	char arr2[10] = "xxxxxxxxxx";
	char* ret = my_strcpy(arr2, arr1);
	printf("%s", ret);// 遇到\0不停止打印
	return 0;
}

4. strncpy的实现

src向dest拷贝前n个

n不能大于dest、src的长度，所以dest空间也要足够大

n分为两个情况：

1、n<src长度

2、n>src长度

第二种情况就是当src里的\0拷贝过去后，把还要拷贝的个数，用\0代替

#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strncpy(char* dest, const char* src, int n)
{
	assert(dest && src);
	char* tmp = dest;
	while ((n--) && (*dest++ = *src++));
	if (n > 0)
	{
		while (n--)
		{
			*dest++ = '\0';
		}
	}
	return tmp;
}
int main()
{
	char str1[] = "abcdeXXXXXXXXXXXX";
	char str2[] = "avcdf";
	char* ret =my_strncpy(str1, str2, 6);
	return 0;
}

三、strcat()函数

1.函数声明原型

char* strcat(char*dest,const char* src)

2. 函数功能

例如：dest [a v s f \0 ]

src [ x x x \0 ]

src连接到dest后

dest[avsfsrc \0]

实现的丝路：先找到dest\0然后将src的内容拷贝到后面

源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加要有用strncat函数

连接后dest最后必须要有\0

dest与src所指的内存空间不能重叠，且dest要有足够的空间来容纳要复制的字符串

所以不能够自己给自己拷贝是因为\0已经被覆盖了而strcat要追加到\0才停止，\0都没了怎么停止，所以数组越界然后崩溃。！！！！！！！！！！！！

3.strcat的实现

#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while(*dest)// 找\0
	{
		dest++;
	}
	while (*dest++ = *src++)//拷贝过去
	{
		;
	}
	return ret;

}

int main()
{
	char str1[] = "abcded\0xxxxxxx";
	char str2[] = "abc";
	
	printf("%s", my_strcat(str1, str2));
	return 0;
}
//打印abcdedabc

4.strncat

这代码和strncpy很像

从dest\0位置开始追加

追加时遇到\0不在追加，就算还没到达n的长度也要停止，

#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strncat(char* dest, const char* src, int n)
{
	assert(dest && src);
	char* tmp = dest;
	while (*++dest);
	while ((n--) && (*dest++ = *src++));//控制遇到\0就停止

	return tmp;
}
int main()
{
	char str1[] = "abcde\0XXXXXXXXXXXX";
	char str2[] = "avcdf";
	char* ret = my_strncat(str1, str2, 7);
	return 0;
}// 最后dest[abcdeavcdf\0XXXXXXX]

四、Strcmp

1.strcmp的原型

int strcmp(const char*str1,const char*str2)

2. 函数的功能

两个数组对应下标的元素进行比较，如果str1小于str2则返回一个小于0的数

相等返回0，大于返回大于；

3.strcmp的实现

#include<stdio.h>
#include<assert.h>
 
int my_strcmp(const* dest, const char* src)
{
	while (*dest == *src)  // 两个元素相等然后进行判断，看看谁到\0了
                           //如果到\0就证明两个字符串相等
	{ 
		if (*dest == '\0')
		{
			return 0;
								
		}
		dest++; src++;

	}
	return *dest - *src;// 返回一个大于或小于或等于0的数
}

int main()
{
	char str1[] = "abcde";
	char str2[] = "abcdrq";
	int ret = my_strcmp(str1, str2);
	printf("%d", ret);
	return 0;
 }

4.strncmp

控制比较的个数

方法一：

#include<stdio.h>
#include<assert.h>
#include<string.h>
int my_strncmp(const char* dest, const char* src, int n)
{
	assert(dest && src);
	while ((n--) && (*dest) && (*src) && (*src == *dest))
	{
		src++;
		dest++;
	}
	return *dest - *src;
}
int main()
{
	char str1[] = "abcdef";
	char str2[] = "abcf";
	int ret = my_strncmp(str1, str2, 2);
	
	printf("%d", ret);
}

方法二：

int my_strcmp(const char* dest, const char* src,int n )
{
	while (*dest == *src&&n--)  // 两个元素相等然后进行判断，看看谁到\0了
						   //如果到\0就证明两个字符串相等
	{
		if (*dest == '\0')
		{
			return 0;

		}
		dest++; src++;

	}
	return (*dest) - (*src);// 返回一个大于或小于或等于0的数
}

五、Strstr

1.函数原型

char * strstr(const char * str,const char * strSet)

2.函数的功能：

Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.
返回指向str1中第一个出现的str2的指针，如果str2不是str1的一部分，则返回空指针。

3.函数的实现(bf算法)

#include<stdio.h>
#include<assert.h>
char* my_strstr(const char* dest, const char* src)
{
	assert(dest && src);
	if (*src=='\0')
	{
		return dest;
	}

	char* cp = dest;
	char* s1=dest;
	char* s2=src;
	
	while (*cp)
	{
		s1 = cp;
		s2 = src;
		while (*s1 && *s2&&*s1==*s2)
		{
			s1++; s2++;

		}
		if (*s2 == '\0')
		{
			return cp;
		}

		cp++;
    }
	return NULL;

}

4.kmp算法实现

六、memcpy（内存拷贝）

1、函数的原型

void * memcpy(void*dest,const void *src,size_t count)

2.函数的功能

memcpy要考虑内存重叠问题

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

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

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

dest和src都不一定时数组，任意的可读写的空间均可

如果要追加数据，则每次执行memcpy后，要将目标数组地址增加到所要追加数据的地址

3.函数的实现

void* my_memcpy(void * dest,const void*src,int n )
{
	assert(dest, src);

	void* ret = dest;
	while(n--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4,5 };

	my_memcpy(arr1, arr2, 20);

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

七、memmove（内存拷贝不用考虑重叠）

memmove与memcpy的区别在于，memmove可以帮我们考虑，重叠的部分，通过要拷贝的个数来达到目的

思路其实很简单，只要画个图模拟一下就清楚了，

src和dest都是先从后面开始拷贝，这样就可以避免重叠问题了；

void* my_memmove(void* dest, const void* str,int n )
{
	assert(dest&& str);
	char* ret = dest;
	if (dest < str)//不会出现重叠
	{
		while (n--)
		{
			*(char*)dest = *(char*)str;
			dest = *(char*)dest + 1;
			str = *(char*)str + 1;

		}
	}
	else//考虑出现重叠的情况	
	{
		while (n--)
		{
			*((char*)dest + n )= *((char*)str + n);

		}
	}
	return ret;
}

八、strtok

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

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

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改
变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

怎么使用

   strtok(str,sep)//第一次使用
   strtok(NULL,sep)//第二次使用
   strtok(NULL,sep)//第三次使用

九、memcmp(内存的比较)

1.函数的原型

int memcmp(const void *buf1,const void * buf2，size_t count )

2.函数的功能

功能：比较内存buf1和buf2的前count个字节。就是字节和字节比
buf1>buf2 返回大于0
buf1<buf2 返回小于0
buf1=buf2  返回0

3.代码的实现


int my_memcmp(const void * arr1, const void * arr2, size_t n)
{
	assert(arr1 && arr2);
	if (n == 0)
	{
		return 0;
	}
	char* s1 = (char*)arr1;
	char* s2 = (char*)arr2;
	while (n-- && *s1 == *s2 )
	{
		s1++;
		s2++;
	}
	if (*s1 != *s2)
	{
		return *s1 - *s2;
	}
	{
		return 0;
	}

}
int main()
{

	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,4,5,6,7 };

	int ret = my_memcmp(arr1, arr2, 12);
	printf("%d ", ret);
	return 0;
}

十、menset

1.函数原型

void * memset(void * dest ,int c ,size_t count )

2. 函数的功能

功能：以str的起始位置开始的n个字节的内存区域用整数value进行填充
返回值：目标str内存起始地址
说明：按字节设置，进行赋值

1.memset用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘ ’或‘/0’
2.如果用malloc分配的内存，一般只能使用memset来初始化
3.memset可以方便的清空一个结构类型的变量或数组,它可以一字节一字节地把整个数组设置为一个指定的值
4.当结构体类型中包含指针时，在用memset初始化时需要特别小心这是因为当用memset初始化为0时会把指针初始化为NULL

5.在使用memset给数组进行初始化时我们只能将数组中的每一个元素初始话为0或者-1，应为memset是一个字节一个字节进行初始化
————————————————
版权声明：本文为CSDN博主「一个山里的少年」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_56999918/article/details/120053142

3.函数的实现

#include<stdio.h>
#include<assert.h>
void* my_memset(void* dest, int val, int num)
{
	assert(dest);
	char* s1 = (char*)dest;
	void* ret = dest;
	while (num--)
	{
		*s1 = (char)val;
		s1++;
	}
	return ret;
}
int main()
{
	int arr[10];
	my_memset(arr, -1, 40);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);//-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
	}
}

2023框框

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
常见的字符串操作函数详解

文章目录字符串操作函数实现详解一、模拟实现strlen函数1.strlen原型2.strlen功能3.strlen 实现的方法和思路A.暴力求解B.递归方法C.指针—指针二、模拟实现strcpy（）1.函数原型2.函数的功能3.strcpy的实现4. strncpy的实现三、strcat()函数1.函数声明原型2. 函数功能3.strcat的实现4.strncat四、Strcmp1.strcmp的原型2. 函数的功能3.strcmp的实现4.strncmp五、Strstr1.函数原型2.函数的功能：3.函数
复制链接

扫一扫