震惊 C语言竟然还有这些函数

作者简介：დ旧言~，目前大一，现在学习Java，c，Python等
座右铭：松树千年终是朽，槿花一日自为荣。
望小伙伴们点赞收藏✨加关注哟

⛵前言

C语言初阶中我们了解到函数，而我们最初认识的函数都是我们自己实现的。在C语言中为了使代码更加的便捷，属于有自己的函数，这些函数称之为内置函数，直接使用就可以了，那大家跟上我的步伐，看看C语言中有哪些函数值得我们学习。

⛵主体

☺️strlen函数

**求字符串长度：**其实这个函数我们已经刻入DNA中了，太熟啦，简单的再了解一下，strlen返回的是字符串长度，当遇到’\0’就停下，形参是const char * str，是一个常量。

⭐strlen使用

传参strlen（arr）//这里arr是字符串数组
引头文件#include

#include
//引用头文件
#include
int main()
{
	char arr[] = "abcdef";
	int ret = strlen(arr);
	printf("%d\n", ret);
	return 0;
}

⭐strlen模拟

#include
#include

int my_strlen(const char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	//初始化数组
	char arr[] = "abcdef";
	//调用函数
	int ret = my_strlen(arr);
	//打印
	printf("%d\n", ret);
	return 0;
}

因为在strlen参数中需要const防止字符串改变，所以在模拟中参数中加上const
这里也可以用递归的方法来实现，有兴趣的小伙伴自己可以试试

☺️strcpy函数

**字符串的拷贝：**使source（来源）拷贝到destination（目的地），并且source（来源）不能改变，因此加上const。
注意：

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

⭐strcpy使用

#include
#include
int main()
{
	char arr1[] = "abcdef";
	char arr2[50];
	int ret = strcpy(arr2,arr1);
	printf("%s\n", ret);
	return 0;
}

在拷贝的时候，连arr1的’\0’都拷贝在arr2中去

⭐strcpy模拟

#include
#include
char* my_strcpy(char* dest, const char* src)
{
	//设置返回值
	char* ret = dest;
	//断言，防止为空指针
	assert(dest != NULL);
	assert(src != NULL);
	while (*src)
	{
		*dest = *src;
		dest++;
		src++;
	}
	//这里把最后的'\0',拷贝到dest中
	*dest = *src;
	return ret;
}

int main()
{
	//定义两个字符串
	char arr1[] = "abcedf";
	char arr2[50] = { 0 };
	//调用函数
	my_strcpy(arr2, arr1);
	//打印
	printf("%s\n", arr2);
	return 0;
}

这里也有简写版

#include
#include
char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

int main()
{
	//定义两个字符串
	char arr1[] = "abcedf";
	char arr2[50] = { 0 };
	//调用函数
	my_strcpy(arr2, arr1);
	//打印
	printf("%s\n", arr2);
	return 0;
}

☺️strcat函数

字符串的连接：使source（来源）连接到destination（目的地），并且source（来源）不能改变，因此加上const。
注意：

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

⭐strcat使用

#include
#include
int main()
{
	char arr1[] = "abcdef";
	char arr2[50] = "abc";
	int ret = strcat(arr2,arr1);
	printf("%s\n", ret);
	return 0;
}

⭐strcat模拟

#include
#include
char* my_strcat(char* dest, const char* src)
{
	//初始化返回值
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	//先让的dest指向'\0'
	while (*dest)
	{
		dest++;
	}
	//再赋值
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

int main()
{
	//初始化字符串
	char arr1[] = "abcdef";
	char arr2[50] = "abc";
	//调用函数
	my_strcat(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

☺️strcmp函数

字符串的比较：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
在同一个位置比较字符，有一个大，那个字符就大。

⭐strcmp使用

#include
#include

int main()
{
	char arr1[] = "abcedf";
	char arr2[] = "abcedg";
	int ret = strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

⭐strcmp模拟

#include
#include

int my_strcmp(const char* src, const char* dest)
{
	//定义返回值
	int ret = 0;
	//断言
	assert(src != NULL);
	assert(dest != NULL);
	while (!(ret = *(unsigned char*)src - *(unsigned char*)dest) && *dest)
		++src, ++dest;
	if (ret < 0)
		ret = -1;
	else if (ret > 0)
		ret = 1;
	return(ret);
}

int main()
{
	//定义字符数组
	char arr1[] = "abcedf";
	char arr2[] = "abcedg";
	//调用函数
	int ret = my_strcmp(arr1, arr2);
	//打印
	printf("%d\n", ret);
	return 0;
}

☺️strncpy函数

字符串的拷贝：这里和strcpy很相似，多了一个参数，size_t num，在来源的字符串中拷贝num个字符。

⭐strncpy使用

#include
#include

int main()
{
	char arr1[] = "abcedf";
	char arr2[] = "######";
	strncpy(arr1, arr2,6);
	printf("%s\n", arr1);
	return 0;
}

☺️strncat函数

字符串的连接：这里比strcat多了一个参数，size_t num，需要再来源字符串中连接num个数字符

⭐strncat使用

#include
#include

int main()
{
	char arr1[50] = "abcedf";
	char arr2[50] = "######";
	strncat(arr1, arr2,5);
	printf("%s\n", arr1);
	return 0;
}

☺️strncmp函数

字符串的比较：这里和strncmy很相似，多了一个参数，size_t num，比较num个字符。

⭐strncmy使用

#include
#include

int main()
{
	char arr1[50] = "abcedf";
	char arr2[50] = "abf";
	int ret = strncmp(arr1, arr2, 3);
	printf("%d\n", ret);
	return 0;
}

☺️strstr函数

字符串找字符串：返回指向第一次出现的字符串2在里面字符串1，或空指针，如果字符串2不属于字符串1。需要一个参数来接收传来的地址

⭐strstr使用

#include
#include

int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	char* ret = strstr(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}

⭐strstr模拟

#include

char* my_strstr(char *str1, char* str2)
{
	char* cp = str1;
	//定义返回的值
	char* s1 = cp;
	char* s2 = str2;
	//判断str2是否为空字符串
	if (*str2 == '\0')
		return str1;
	//变历
	while (*cp)
	{
		//开始匹配
		s1 = cp;
		s2 = str2;
		while (*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return cp;

		cp++;
	}
	return NULL;
}

int main()
{
	//定义两个字符串
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	//调用函数
	char* ret = my_strstr(arr1, arr2);
	if (ret != NULL)
		printf("%s\n", ret);
	else
		printf("找不到\n");
	return 0;
}

☺️strtok函数

字符分割函数

char* str:字符串，需要分割的字符串
const char* delimiters：分割字符串
需要一个char*指针接收该函数的返回值

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

⭐strstr使用

#include
#include
int main()
{
	char arr[] = "jiuyan@hello@123456";
	char copy[30];
	strcpy(copy, arr);
	char sep[] = "@.#";
	char* ret = NULL;

	for (ret = strtok(copy, sep); ret != NULL; ret=strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

☺️memcpy函数

与strcpy很相似，这个函数任何类型都可以拷贝，第三个参数是需要拷贝的字节数

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 ‘\0’ 的时候并不会停下来。

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

⭐memcpy使用

#include
#include
int main()
{
	float arr1[] = { 1.0,2.0,3.0 };
	float arr2[5] = { 0 };
	//将arr1中的内容，拷贝到arr2中
	memcpy(arr2, arr1, 8);
	//    float* float*
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%f ", arr2[i]);
	}

	return 0;
}

float是四个字节

⭐memcpy模拟

#include
#include
#include

void* my_memcpy(void* dest, const void* src, size_t num)
{
	//定义返回值
	void* ret = dest;
	//断言
	assert(src && dest);
	//循环
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	//定义数组
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 00 00 00
	int arr2[20] = { 0 };
	//调用函数
	my_memcpy(arr2, arr1, 21);
	int i = 0;
	//变历
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

☺️memmove函数

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

⭐memmove使用

#include 
#include 
int main()
{
	char str[] = "memmove can be very useful......";
	memmove(str + 20, str + 15, 11);
	puts(str);
	return 0;
}

⭐memmove模拟

#include 
#include 
#include
void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)
	{
		//前->后
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (num--)//20
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	//             1 2 1 2 3 4 5 8 9 10
	my_memmove(arr1, arr1+2, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

☺️memcmp函数

这里我就不再介绍啦其实这里和strcmp太相似啦。

⛵拓展

函数	如果他的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’
isdigit	十进制数字 0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母af，大写字母AF
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母az或AZ
isalnum	字母或者数字，az,AZ,0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

当然上面的函数大家不用记，大家用cplusplus这个网站来查询这些函数，那咱们举个例子，留个印象把。

#include 
#include 
int main()
{
	int i = 0;
	char str[] = "Test String.\n";
	char c;
	while (str[i])
	{
		c = str[i];
		if (isupper(c))
			c = tolower(c);
		putchar(c);
		i++;
	}
	return 0;
}

⛵结束语

今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小说手给博主一键三连，有你们的支持是我最大的动力，回见。