字符串函数和字符函数 c语言

字符函数和字符串函数

函数介绍

1. 求字符串长度
strlen

size_t（const char * str）

字符串以’\0’为结束的标志 strlen返回的是遇到’\0’前字符的个数
函数的返回值是size_t(无符号）
模拟实现

1.递归 不创建临时变量

#include<stdio.h>
#include<assert.h>
size_t my_strlen(char * str)
{
	if (*str == '\0')
	{
		return 0;
	}
	return 1 + my_strlen(str + 1);

2.指针相减

size_t my_strlen(const char *str)
{
	assert(str != NULL);
	const char *start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}

3.创建临时变量

size_t my_strlen(const char * str)
{
	assert(str != NULL);
	int count = 0;
	while (*str != '\0')
	{
		str++;
		count++;
	}
	return count;
}

长度不受限制的字符串函数
1.strcpy ：字符串拷贝的函数

char* strcpy(char * destination, const char * source )；

源字符串必须以’\0’结束 源字符串拷贝到目标字符串时’\0’也要进行拷贝
目标空间必须足够大 且可以进行修改
模拟实现：

char* strcpy(char * dest, const char * src )
{	
    char * ret=dest;
	assert(dest!=NULL);
	assert(src!=NULL);
	//将src依次赋值给dest ,当src为'\0'时，条件为假，跳出循环
	while(*dest++=*src++)
	{
	;
	}
	return ret;
}

2.strcat:字符串追加函数

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

源字符串必须以’\0’结束
目标空间需要足够大且可以修改
不能自己给自己追加，在追加的过程中，已经修改了源字符串的值
模拟实现：

char* my_strcat(char* dest, const char* src)
{
	assert(dest != NULL);
	assert(src != NULL);
	char* ret = dest;
	//先寻找'\0'
	while (*dest)
	{
		dest++;
	}
	//再从'\0'处开始进行拷贝
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

3.strcmp:字符串比较函数.比的是ASCII值的大小

第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

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

模拟实现

#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* s1,const char* s2)
{
	assert(s1 != NULL);
	assert(s2 != NULL);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
			return 0;
		s1++;
		s2++;
	}
	return *s1 - *s2;
	
}

长度受限制的字符串函数
1.strncpy
拷贝num个字符从源字符串到目标空间。

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

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

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

3.strncmp

int strncmp ( const char * str1, const char * str2, size_t num );

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
字符串查找
1.strstr :判断一个字符串是否是另一个字符串的子串
模拟实现：

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 != NULL);
	assert(str2 != NULL);
	char* cp = str1;//创建一个cp来临时存储每一次遍历str1时的开始地址
	char*  bf = str2;
	char* s1 = NULL;//创建一个空指针s1
	if (*str2 == '\0')
	{
		return NULL;
	}
	while (*cp)
	{
		s1 = cp;
		bf = str2;
		while (*s1&&*bf && (*s1 == *bf))//判断s1不为空，bf不为空，s1和bf是否相等
		{
			s1++;
			bf++;
		}
		if (*bf == '\0')//遍历完str2,str2是str1的子字符串，返回cp
		{
			return cp;
		}
		cp++;//不是子字符串，让cp向后指 再进行遍历判断
	}

2.strtok:

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

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

内存操作函数：
1.memcpy：

void * memcpy ( void * dest, const void * src, size_t num );

函数memcpy从src的位置开始向后复制num个字节的数据到dest的内存位置。
这个函数在遇到 ‘\0’ 的时候不会停下来。
函数不能处理源内存和目标内存重叠的情况
模拟实现：

void* my_memcpy(void* dest, const void* src, size_t count)
{	
	void* ret = dest;
	assert(dest!= NULL);
	assert(src != NULL);


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

2.memmove:

void*memmove(void* dest,const void * src,size_t num);

函数处理的源内存块和目标内存块是可以重叠的。
模拟实现：

void* my_memove(void* dest, const void* src, size_t count)
{	
	void* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	if (dest < src)
	{	//从前往后拷贝
		while (count--)
		{
			*(char *)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	//从后往前拷贝 
	else
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return ret;
}