C语言字符函数、字符串函数、内存函数总结

最新推荐文章于 2024-09-16 08:54:02 发布

我要升天！

最新推荐文章于 2024-09-16 08:54:02 发布

阅读量1k

点赞数 25

文章标签： c语言开发语言 vscode

本文链接：https://blog.csdn.net/zxybf_/article/details/136788251

版权

这里写目录标题

字符分类函数
字符转换函数
strlen的使用和模拟实现
strcpy的使用和模拟实现
strcat的使用和模拟实现
strcmp的使用和模拟实现
strncpy的使用和模拟实现
strncat的使用和模拟实现
strncmp的使用和模拟实现
strstr的使用和模拟实现
strtok的使用和模拟实现
strerror的使用
memcpy使⽤和模拟实现
memmove使⽤和模拟实现
memset使⽤
memcmp使⽤

字符分类函数

C语言中有一些函数，专门是用来进行字符分类的，使用这些函数需要包含头文件ctype.h
1.iscntrl可以判断字符是否为控制字符，如果参数符合条件就返回真。
2.isspace可以判断字符是否为空白字符，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isspace(' '));//打印的是大于0的数字
	return 0;
}

3.isdigit可以判断字符是否为十进制数字’0’-'9’字符，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isdigit('4'));//打印的是大于0的数字
	return 0;
}

5.isxdigit可以判断字符是否为十六进制数字，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isxdigit('a'));//打印的是大于0的数字
	return 0;
}

6.islower可以判断字符是否为小写字符，如果参数符合条件就返回真。


#include<ctype.h>
int main()
{
	printf("%d\n", islower('a'));//打印的是大于0的数字
	return 0;
}

7.isupper可以判断字符是否为大写字符，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isupper('A'));//打印的是大于0的数字
	return 0;
}

8.isalpha可以判断字符是否为字母字符，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isalpha('A'));//打印的是大于0的数字
	return 0;
}

9.isalnum可以判断字符是否为字母和数字（0-9）字符，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isalnum('A'));//打印的是大于0的数字
	return 0;
}

10.ispunct可以判断字符是否为标点符号，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", ispunct('.'));//打印的是大于0的数字
	return 0;
}

11.isgraph可以判断字符是否为图形字符，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isgraph('n'));打印的是大于0的数字
	return 0;
}

12.isprint可以判断字符是否为可打印字符，包括空白字符和图形字符，如果参数符合条件就返回真。

#include<ctype.h>
int main()
{
	printf("%d\n", isprint('n'));//打印的是大于0的数字
	return 0;
}

字符转换函数

C语言提供了两个字符转换函数，toupper将小写转换成大写，tolower将大写转换成小写。
例如：

int main()
{
	char arr[] = "I am a student";
	int i = 0;
	char b = 0;
	while (arr[i])
	{
		b=toupper(arr[i]);//b=tolower(arr[i]);
		putchar(b);
		i++;
	}
	return 0;
}

在这里插入图片描述

strlen的使用和模拟实现

1.strlen的使用
strlen函数是用来计算字符串的长度的，计算的是’\0’之前的字符个数。
例如：

size_t strlen(const char* string);

strlen函数的返回值的size_t类型的，参数是char *的指针。
例如：

int main()
{
	char arr[] = "wqrqtt";
	size_t len = strlen(arr);
	printf("%zd\n", len);//打印的是6；
	return 0;
}

2.strlen的模拟使用
例如：

#include<assert.h>
size_t my_strlen(const char* str)
{
	assert(str != NULL);
	int count = 0;
	while (*str != '\0')
	{
		str++;
		count++;
	}
	return count;

}
int main()
{
	char arr[] = "qwreryy";
	size_t len = my_strlen(arr);
	printf("%zd\n", len);
	return 0;
}

strcpy的使用和模拟实现

1.strcpy的使用
strcpy是字符串拷贝函数，用来拷贝字符串的。需要包含头文件#include<string.h>
例如：

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

strcpy函数有两个参数，一个参数是目标空间的地址，一个参数是源函数的地址，再拷贝过程中，'\0’也将会背拷贝。
例如：

#include<string.h>
int main()
{
	char arr[] = "abcd";
	char arr2[20] ={ 0 };
	strcpy(arr2, arr);
	printf("%s\n", arr2);//打印的是abcd
	return 0;
}

2.strcpy的模拟实现
例如：


#include<string.h>
char* my_strcpy(char* dest, const char* src)
{
	char* s = dest;
	assert(dest && src);
	while (*dest++ = *src++)//遇到'\0'就跳出循环
		;
	return s;
}
int main()
{
	char arr[] = "abcd";
	char arr2[20] = "XXXXXXXXXXXXXXX";
	my_strcpy(arr2, arr);
	printf("%s\n", arr2);
	return 0;
}

strcat的使用和模拟实现

1.strcat的使用
strcat是字符串连接函数，用来连接字符串的。
例如：

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

strcat函数的返回类型是char *类型的指针。第一个参数是目标函数的地址，第二个参数是源函数的地址。
例如：

int main()
{
	char arr[] = "asdf";
	char arr2[20] = "zzz";
	strcat(arr2, arr);
	printf("%s\n", arr2);//打印的结果是zzzasdf
	return 0;
}

2.strcat的模拟使用
例如：

#include<stdio.h>
#include<string.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest != '\0')
	{
		dest++;
	}//找到'\0'，从'\0'那里开始连接
	while (*dest++ = *src++)
		;
	return ret;
}
int main()
{
	char arr[] = "asdf";
	char arr2[20] = "zzz";
	my_strcat(arr2, arr);
	printf("%s\n", arr2);//打印的结果是zzzasdf
	return 0;
}

strcmp的使用和模拟实现

1.strcmp的使用
```strcmp``是字符串比较函数，用来比较字符串的大小，从第一个字符开始比较，比较的是字符的ASCII码值。
如果第一个字符串大于第二个字符串，则返回大于0的数。
如果第一个字符串小于第二个字符串，则返回小于0的数。
如果第一个字符串等于第二个字符串，则返回0。
例如：

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcddef";
    int ret = strcmp(arr1, arr2);
	printf("%d\n", ret);//因为e的ASCII码值大于d的ASCII码值，打印的是大于0的数，
	return 0;
}

2.strcmp的模拟实现
例如：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
	if (*str1 == '\0')//如果相等就返回0
	return 0;
		str1++;
		str2++;
	}
	
	return *str1 - *str2;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcddef";
    int ret = my_strcmp(arr1, arr2);
	printf("%d\n", ret);
	return 0;
}

strncpy的使用和模拟实现

1.strncpy也是字符串拷贝函数，但是它可以限制拷贝的字符个数。
例如：

char * strncpy(char *dest,const char *src,size_t num)

size_t num是需要拷贝的字符个数。
例如：

int main()
{
	char arr[] = "abcdef";
	char arr2[20] = { 0 };
	strncpy(arr2,arr, 3);
	printf("%s\n", arr2);//打印的是abc
	return 0;
}

2.strncpy的模拟实现
例如：

char* my_strncpy(char* dest, const char* src, size_t num)
{
	char* ret = dest;
	assert(dest && src);
	while (num--)
	{
		if (*src == '\0')//字符个数小于num时
			break;
		else
		*dest = *src;
		dest++;
		src++;
	}
	num++;
	while(num--)//后面补0
		*dest++ = '\0';
	return ret;
}
int main()
{
	char arr[] = "ab";
	char arr2[20] = "XXXXXXXXXXXXXXXXXXXX";
	my_strncpy(arr2,arr, 8);
	printf("%s\n", arr2);
	return 0;
}

strncat的使用和模拟实现

1.strncat的使用
strncat可以限制连接字符的个数。
例如：

char *strncat(char *dest,const char *src,size_t num)

size_t num是需要连接的字符个数。
例如：

int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = "asd";
	strncat(arr2, arr1, 3);
	printf("%s\n", arr2);
	return 0;
}

2.strncat的模拟使用
例如：

char* my_strncat(char* dest, const char* src, size_t num)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest != '\0')//找到末尾的'\0'
	{
		dest++;
	}
	while ((num--) && (*dest++ = *src++))
	{
		;
	}
	if (*dest != '\0')//如果数组长度小于num，则在后面追加一个'\0'
		*dest = '\0';
	
	return ret;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = "asd\0xxxxxxx";
	my_strncat(arr2, arr1, 3);
	printf("%s\n", arr2);
	return 0;
}

strncmp的使用和模拟实现

1.strncmp的使用
strncmp可以用来限制字符串比较的字符个数。比较num个字符，str1大于str2，就返回大于0的数；小于的话就返回小于0的数，等于的话就返回0.
例如：

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

2.strncmp的模拟实现

int my_strncmp(const char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	while ((num--)&&(*str1 == *str2))
	{
		str1++;
		str2++;
	}
	return *str1 - *str2;
}
int main()
{
	char arr1[] = "abadef";
	char arr2[] = "abcdeef";
	int ret = my_strncmp(arr1, arr2, 3);
	printf("%d\n", ret);
	return 0;
}

strstr的使用和模拟实现

1.strstr的使用
strstr函数是用来一个字符串是否存在与另一个字符串中，如果存在，则返回字符串在另一个字符串中第一次出现的位置。字符串的比较匹配不包括’\0’,'\0’作为字符串结束的标志。

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

例如：

int main()
{
	char arr1[] = "abbcdef";
	char arr2[] = "bcd";
	printf("%s\n", strstr(arr1, arr2));//打印的是bcdef;
	return 0;
}

2.strstr的模拟实现
例如：

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* s1 = str1;
	const char* s2 = str2;
	char* cvb = str1;//cvb是用来找到开始比较的那个字符的地址。
	if (!*str1)
		return (char*)str1;
	while (*cvb)
	{
		s2 = str2;
		s1 = cvb;
		while (*s1 == *s2)
		{
			s1++;
			s2++;
			if (*s2 == '\0')
				return cvb;
		}
		cvb++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "abbcdef";
	char arr2[] = "bcd";
	printf("%s\n", my_strstr(arr1, arr2));
	return 0;
}

strtok的使用和模拟实现

1.strtok的使用
strtok函数可以打印用分隔符分隔的字符串。

char * strtok(char *str1,const char *str2)

第二个参数str2定义了用作分隔符的字符集合。
第一个参数str1是一个字符串，是字符串和分隔符组成的字符集合。
注意：使用strtok函数时，会改变原字符串的内容，所以，我们在使用函数之前，应该先对字符串先拷贝一份。
如果函数地第一个参数不为NULL，函数将找到字符串中的第一个标记，并保存它的位置。
如果函数的第一个参数为NULL，函数将在字符串被保存的位置，开始查找下一个标记。
如果字符串中不存在更多的标记，则返回NULL。
例如：

int main()
{
	char arr1[] = "abcdef@zxcvb.zx";
	char arr3[30] = { 0 };
	strcpy(arr3, arr1);
	char arr2[] = "@.";
	char* ret = strtok(arr3, arr2);
	printf("%s\n", ret);//打印的是abcdef
	return 0;
}

如果还想打印后面的内容，我们需要给第一个参数为NULL.

例如：

int main()
{
	char arr1[] = "abcdef@zxcvb.zx";
	char arr3[30] = { 0 };
	strcpy(arr3, arr1);
	char arr2[] = "@.";
	char* ret = strtok(arr3, arr2);
	printf("%s\n", ret);打印的是abcdef
	ret = strtok(NULL, arr2);
	printf("%s\n", ret);//打印的是zxcvb
	return 0;
}

我们也可以使用一种更加巧妙地方式。
例如：

int main()
{
	char arr1[] = "abcdef@zxcvb.zx";
	char arr3[30] = { 0 };
	strcpy(arr3, arr1);
	char arr2[] = "@.";
	for (char* ret = strtok(arr3, arr2); ret != NULL; ret = strtok(NULL, arr2))
	{
		printf("%s\n", ret);
	}
	return 0;
}

在这里插入图片描述

strerror的使用

1.strerror函数是用来返回错误信息字符串的地址的。
函数只有一个参数，就是错误码。
例如：

int main()
{
	for (int i = 0; i < 10; i++)
	{
		printf("%s\n", strerror(i));
	}
	return 0;
}

在这里插入图片描述

memcpy使⽤和模拟实现

1.memcpy函数内存拷贝函数，可以将src后面的num个字节的内容拷贝到dest中。在拷贝过程中遇到’\0’时不会停止的，如果src后面的内存和dest后面的内存重叠，结果都是未定义的。

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

例如：

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

2.memcpy的模拟实现
例如：

void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	while (num--)
	{
		*(((char*)dest)++) = *(((char*)src)++);
	}
	return dest;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 0 };
	my_memcpy(arr2, arr1, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

memmove使⽤和模拟实现

1.memmove的使用
memeove``和``memmove的功能有相似之处，但是memmove功能更加强大，如果dest内存块和src的内存块有重叠时，也可以使用。
例如:

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

2.memmove的模拟实现
例如：

void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest > src)
	{
		while (num--)//从后往前放
		{
			*((char*)dest+num) = *((char*)src+num);
		}
	}
	else
	{
		while (num--)//从前往后放
		{
			*(((char*)dest)++) = *(((char*)src)++);
		}
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1 + 3, arr1, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);//打印的是1 2 3 1 2 3 4 5 9 10
	}
	return 0;
}

memset使⽤

memset是用来设置内存的，将内存中的值以字节为单位设计成自己想要的值。

void* memset(void* s1, int value, size_t num)

例如：

int main()
{
	char arr1[] = "hello world";
	memset(arr1 + 2, 'x', 3);
	printf("%s\n",arr1);//打印的是hexxx world
	return 0;
}

2.memset的模拟使用

void* my_memset(void* s1, int value, size_t num)
{
	void* ret = s1;
	assert(s1);
	while (num--)
	{
		*(char*)s1 = value;
		s1 = (char*)s1+1;
	}
	return ret;
}
int main()
{
	char arr1[] = "hello world";
	my_memset(arr1 + 2, 'x', 3);
	printf("%s\n",arr1);//打印的是hexxx world
	return 0;
}

memcmp使⽤

1.memcmp的使用
该函数使用比较str1和str2后面的num个字节。
在这里插入图片描述

int memcmp(const void *str1,const void *str2,size_t num)

例如：

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcddef";
	int ret = memcmp(arr1, arr2, 5);
	printf("%d\n", ret);//ret > 0
	return 0;
}

2.memcmp的模拟实现
例如：

int my_memcmp(const void* str1, const void* str2, size_t num)
{
	assert(str1 && str2);
	while ((num--) && (*(char*)str1 == *(char*)str2))
	{
		str1 = (char*)str1 + 1;
		str2 = (char*)str2 + 1;
	}
	return *(char *)str1 - *(char *)str2;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcddef";
	int ret = my_memcmp(arr1, arr2, 5);
	printf("%d\n", ret);//ret > 0
	return 0;
}