C语言中常见的字符函数和字符串函数

1.求字符串的长度

strlen函数：
1.函数介绍
size_t strlen (const char * str);

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

//strlen函数的模拟实现
#include<iostream>
//方法1：计数器实现的方式
int my_strlen1(const char * str)
{
	int count = 0;
	while(*str)
	{
		count++;
		str++;
	}
	return count;
}
//递归--不创建临时的计数器
int my_strlen2(const char * str)
{
	if(*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
//指针 - 指针的方式
int my_strlen3(char * str)
{
	char * p = str;
	while(*p != '\0')
	{
		p++;
	}
	return str - s;
}
int main()
{
	return 0;
}

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

1.strcpy字符串拷贝

size_t strlen(const char * str);

• 原字符串必须以’\0’结束。
• 会将原字符串中的’\0’拷贝到目标字符串中
• 目标空间必须足够大，以确保能放下字符串
• 目标空间必须可变
• 模拟实现

//字符串拷贝的时候会覆盖原来的字符串
#include<iostream>
char * my_strcpy(char * dest, const char * src)
{
	if(dest == nullptr || src == nullptr)
		return nullptr;
	char * ret = dest;
	while(*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[10] = "abcdef";
	char arr2[10] = "253";
	printf("%s\n",my_strcpy(arr2,arr1));
	return 0;
}

2.strcat字符串连接

char * strcat (char * destination , const char * source);

• 原字符串必须以’\0’结束
• 目标空间必须有足够大的空间，能容纳下原字符串的内容
• 目标空间必须可修改
• 模拟实现

#include<iostream>
char * my_strcpy(char * dest, const char * src)
{
	if(dest == nullptr || src == nullptr)
		return nullptr;
	char * ret = dest;
	while(*dest)
	{
		dest++;
	}
	while(*(dest++) = *(src++))
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[10] = "abcdef";
	char arr2[10] = "253";
	printf("%s\n",my_strcpy(arr1,arr2));
	return 0;
}

3.strcmp比较两个字符串的大小

int strcmp ( char * destination , const char * source);

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

int my_strcmp(const char * str1 , const char * str2)
{
	if(str1 == nullptr || str2 == nullptr)
		return -2;
	while(*str1 == *str2)
	{
		if(*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	int ret = *str1 - *str2;
	if ( ret < 0 )  
	      ret = -1 ;
	else if ( ret > 0 )
	      ret = 1 ;
	return ret;
}
int main()
{
	int ret = my_strcmp("abca","abc");
	printf("%d",ret); 
	system("pause");
	return 0;
}

三.长度受限制的字符串函数

1.strncpy

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

• 拷贝num个字符从源字符串到目标字符串
• 如果原字符串的长度小于num，则拷贝完源字符串之后，在目标的后面追加上0，直到num个。

char * my_strncpy(char * dest , char * src , int count)
{
	char * ret = dest;
	while(count && (*dest++ = *src++))
	{
		count--;
	}
	if(count)
	{
		while(count)
		{
			*dest == '\0';
		}
	}
	return ret;
}
int main()
{
	char arr[20] = "abcdefg";
	std::cout << my_stncpy(arr,"hello", 3);
	system("pause");
	return 0;
}

2.strnat

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

• 把src所指字符串的前n个字符添加到dest结尾处（覆盖dest结尾处的’\0’）并添加’\0’

char * my_strncat(char * dest , const char * src , int count)
{
	char * ret = dest;
	while(*dest != '\0')
	{
		dest++;
	}
	while(count-- && (*dest++ = *src++))
	{
		;
	}
	return ret;
}
int main()
{
	char str[20] = "hello ";
	std::cout << my_strncat(str,"world 1234" , 5);
	system("pause");
	return 0;
}

3.strncmp

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

• 比较到出现另一个字符不一样或者一个字符串结束或者num个字符全部比较完

int my_strncmp(const char* dest , const char * src ,int count)
{
	if(dest == nullptr || src == nullptr)
		return -2;
	while(count-- && (*dest == *src))
	{
		if(*dest == '\0')
		{
			return 0;
		}
		dest++;
		src++;
	}
	int ret = *dest - *src;
	if (ret < 0)
		ret = -1;
	else if (ret > 0)
		ret = 1;
	return ret;
}
int main()
{
	char str[20] = "abcdefg";
	std::cout << my_strcnmp(str,"hello",5);
	system("pause");
	
}

四.字符串查找

1.strstr查找字符串

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

char * my_strstr(const char* str1,const char * str2)
{
	if(str1 == nullptr || str2 == nullptr)
		return nullptr;
	const char * s1 = str1;
	const char * s2 = str2;
	const char * cp = s1;
	while(cp)
	{
		s1 = cp;
		s2 = str2;
		while(*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if(*s2 == '\0')
			return (char *)cp;
		
		cp++;
	}
	return nullptr;
}

int main()
{
	char * str1 = "ccdaaac";
	char * str2 = "aac";
	std::cout << my_strstr(str1,str2) << std::endl;
	system("pause");
	return 0;
}

2.strtok分解字符串

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

• sep参数是一个字符串，定义了用做分隔符的函数集合。
• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分割符分割的标记。
• strtok哈桑农户找到str中的下一个标记，并将其用’\0’结尾，返回一个指向这个标记的指针。
• strtok函数的第一个参数不为Null，哈桑农户将找到str中的第一个标记，strtok函数将保存它在字符串中的位置
• strtok函数的第一个参数为Null，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
• 如果字符串不存在更多的标记，则返回空指针。

五.内存操作函数

1.memcpy

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

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到’\0’的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的

void * my_memcpy(void * dest, const void * src, size_t count)
{
	void * ret = dest;
	while (count--)
	{
		*(char *)dest = *(char *)src;
		dest = (char *)dest + 1;
		src = (char *)src + 1;
	}
	return ret;
}
int main()
{
	int str1[] = { 1, 2, 3, 4, 5, 6 };
	int str2[20] = { 0 };
	std::cout << my_memcpy(str2, str1, 12);
	system("pause");
	return 0;
}

2.memove

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

• 和memcpy（）的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理

void* my_memmove(void* dest,void* src,int count)
{
	if(dest == nullptr || src == nullptr)
		return;
	void* ret = dest;
    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;
}
int main()
{
	int arr1[] = {1,2,3,4,5,6,7};
	my_memmove(arr1,arr1+2,16);
	system("pause");
	return 0;
}