## **字符函数和字符串函数**❤️❤️❤️❤️❤️❤️

字符函数和字符串函数❤️❤️❤️❤️❤️❤️

**

1. 求字符串长度
   strlen
2. 长度不受限制的字符串长度
   strcpy（拷贝覆盖）
   strcmp（比较）
   strcat（追加）
3. 长度受限制的字符串（需要注明字节个数size—t）
   strncpy
   strncmp
   strncat
4. 查找函数
   strstr
   strtok
5. 错误信息报告 strerror
6. 内存操作函数
   memcpy
   memcat
   memcmp
   memstr

**

**

strlen💕

**

size_t strlen ( const char * str );

1. 字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
2. 参数指向的字符串必须要以 ‘\0’ 结束。
3. 注意函数的返回值为size_t，是无符号的
4. 直接给定字符串的首元素地址即可计算后面‘\0’之前的字符个数。

实现（求字符串长度的三种方法）
一.递归求字符串长度

#include <stdio.h>
#include <assert.h>
int my_strlen(const char* str)
{
	assert(str);
	if (*str != '\0')
		return 1+my_strlen(str + 1);        \\递归 依次+1到了'\0'停止
	else
		return 0;
}
int main()
{
	char arr[] = "abcdefg";
	int len=my_strlen(arr);
	printf("字符串的长度为：%d\n", len);
	return 0;

二.常规方法求字符串长度

#include <stdio.h>
int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;

	}
	return count;
}
int main()
{
	char arr[] = "abcedf";
	int len=my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

三.用地址相减求字符串的长度

#include <stdio.h>
int my_strlen(char* str)
{
	char* start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}
int main()
{
	char arr[] = "abcdefg";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

**

strcpy💕

**

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

1. 源字符串必须以 ‘\0’ 结束。
2. 会将源字符串中的 ‘\0’ 拷贝到目标空间。
3. 目标空间必须足够大，以确保能存放源字符串。
4. 目标空间必须可变。
   实现（逐个拷贝）

#include <stdio.h>
#include <assert.h>
void my_strcpy(char * arr2, char * arr1)
{
	assert(arr2 && arr1);
	while (*arr2++ = *arr1++)
	{
		;
	}
}
int main()
{
	char arr1[] = "hehe";
	char arr2[1000] = { 0 };
	my_strcpy(arr2, arr1);
	printf("%s", arr2);
	return 0;

**

strcat💕

**

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

1. 源字符串必须以 ‘\0’ 结束。
2. 目标空间必须有足够的大，能容纳下源字符串的内容。
3. 目标空间必须可修改。

实现

#include <stdio.h>
#include <assert.h>
char* my_strcat(char* arr1, const char* arr2)
{
	assert(arr1 && arr2);
	char* ret = arr1;
	while (*arr1 != '\0')  **首先找到'\0'然后在往后边追加。**
	{
		arr1++;
	}
	while (*arr1++ = *arr2++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[100] = "abcdef";
	char arr2[] = "ghjkl";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

**

strcmp💕

**

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

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

注：千万要注意比较的不是字符串的长度，而是比较的字符串的大小即逐个比较两个串中对应的字符，字符大小按照ASCII码值确定，从左向右比较，如果遇到不同字符，所遇第一对不同字符的大小关系就确定了两个字符串的大小关系，如果未遇到不同字符而某个字符串首先结束，那么这个字符串是较小的，否则两个字符串相等。

实现（逐个字符比较）

#include <stdio.h>
int my_strcmp(char* arr1, char* arr2)
{
	while (*arr1 == *arr2)
	{
		if (*arr1 == '\0')
		
			return 0;
			arr1++;
			arr2++;
		
	}
		if (*arr1 > *arr2)
		{
			return 1;
		}
		else
		{
			return -1;
		}
	
}
int main()
{
	char arr1[] = "ab";
	char arr2[] = "ab";
	int ret = my_strcmp(arr1, arr2);
	printf("%d", ret);
	return 0;

**

strncpy💕

**

char * strncpy ( char * destination, const char * source, size_t num）；

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

**

strncat💕

**

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

给定字符数量的strcat

**

strncmp💕

**

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

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

**

strstr💕

**

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

1.如果查找到所查内容则返回所查内容的地址
2.如果查找不到则返回空指针 NULL

实现（查找一个字符串中是否有另一个字符串中的内容）

#include <stdio.h>
char* my_strstr(char* arr1, char* arr2)
{
	char* s1 = NULL;
	char* s2 = NULL;
	char* cp = (char*)arr1;
	while (*cp)
	{
		s1 = cp;
		s2 = (char*)arr2;
		while (s1 && s2 && s1 == s2)
		{
			s1++;
			s2++;
		}
		if (s2 == '\0')
		{
			return cp;
		}
		cp++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	char*p=my_strstr(arr1, arr2);
	if (p == NULL)
	{
		printf("找到了\n");
	}
	else
	{
		printf("%s\n", p);
	}
	return 0;
}

**

strtok💕

**

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

1. sep参数是个字符串，定义了用作分隔符的字符集合
2. 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
3. strtok函数找到str中的下一个标记，并将其改为 \0 结尾，返回一个指向这个标记的指针。
4. strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
5. strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
6. 如果字符串中不存在更多的标记，则返回 NULL 指针。

strtok函数的使用

**

strerror💕

**

char * strerror ( int errnum );

返回错误码，所对应的错误信息。

**

memcpy💕

**

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

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

实现（指定字符数量进行覆盖拷贝）

#include <stdio.h>
#include <assert.h>
void my_memcpy(void* dest, void* src, size_t num)
{
	assert(dest && src);
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
}
int main()
{
	int arr1[] = { 0,1,2,3,4,5,6,7,8 };
	int arr2[100] = { 0 };
	int num = 0;
	my_memcpy(arr2, arr1,36);
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", arr2[i]);
	}
	return 0;
}

**

memmove💕

**

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

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

实现

#include <stdio.h>
#include <assert.h>
void my_memmove(void* dest, void* src, size_t num)
{
	assert(dest && src);
	if (dest < src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
}
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9};
	my_memmove(arr + 2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d", arr[i]);
	}
	return 0;
}

**

memcmp💕

**

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

比较从ptr1和ptr2指针开始的num个字节

❤️❤️😘😘❤️❤️😘😘❤️❤️😘😘

小牛仔在一点点进步希望大佬指点，冲鸭冲鸭冲鸭冲鸭冲鸭冲鸭冲鸭冲鸭冲鸭！！！