【C语言】字符串+内存函数及其模拟实现

字符串+内存函数

• 一、基本介绍及使用
• • 1.1 strlen
  • 1.2 strcpy
  • 1.3 strcat
  • 1.4 strcmp
  • 1.5 strncpy
  • 1.6 strncat
  • 1.7 strncmp
  • 1.8 strstr
  • 1.9 strtok
  • 1.10 strerror
  • 1.11 memcpy
  • 1.12 memmove
  • 1.13 memcmp
• 二、常见库函数模拟实现
• • 2.1 strlen模拟实现
  • 2.2 strcpy模拟实现
  • 2.3 strcat模拟实现
  • 2.4 strstr模拟实现
  • 2.5 strcmp模拟实现
  • 2.6 memcpy模拟实现
  • 2.7 memmove模拟实现

一、基本介绍及使用 1.1 strlen

size_t strlen( const char *string );

求字符串长度函数，strlen函数返回的’’前的字符个数(不包括’’)。

使用：

int main()
{
	char* str = "abcdef";
	printf("%zu", strlen(str));
	return 0;
}

结果：
6

---

1.2 strcpy

char *strcpy( char *strDestination, const char *strSource );

拷贝字符串，把strSource的字符串拷贝到strDestination里。
注意：
1）源头的’’会拷贝到目标空间。
2）目标空间必须足够且可改变。

使用：

int main()
{
	char arr[10] = { "sss" };
	char* str = "abcdef";
	strcpy(arr, str);
	printf("%s", arr);
	return 0;
}

结果：
abcdef

---

1.3 strcat

char *strcat( char *strDestination, const char *strSource );

追加字符串，目标空间的’’被源字符串首字符替换，最后返回strDestination的地址。
注意：
1）目标空间必须足够大且可修改，能放的下两者之和。
2）不能自己追加自己，会导致死循环

使用：

int main()
{
	char arr[10] = { "sss" };
	char* str = "abc";
	strcat(arr, str);
	printf("%s", arr);
	return 0;
}

结果：
sssabc

---

1.4 strcmp

int strcmp( const char *string1, const char *string2 );

比较字符串，从两个字符串第一个字符串开始比较，如果相等，就往后比（比的是ascii）。
注意：
1）string1 > string2 返回大于0的数字
2）string1 = string2 返回等于0的数字
3）string1 < string2 返回小于0的数字

使用：

int main()
{
	char* str1 = "abt";
	char* str2 = "abc";
	int ret = strcmp(str1, str2);
	printf("%d", ret);
	return 0;
}

结果：
1

---

1.5 strncpy

char *strncpy( char *strDest, const char *strSource, size_t count );

有长度限制的拷贝字符串，把strSource的前count字符串拷贝到strDestination里。
注意：
1）如果源字符串大小小于count，那么拷贝到’’直接补’’。

使用：

int main()
{
	char str1[] = "sss";
	char* str2 = "abc";
	strncpy(str1, str2, 2);
	printf("%s", str1);
	return 0;
}

结果：
abs

---

1.6 strncat

char *strncat( char *strDest, const char *strSource, size_t count );

有长度限制的追加字符串，把strSource的前count字符串追加到strDestination里。

使用：

int main()
{
	char str1[10] = "sss";
	char* str2 = "abc";
	strncat(str1, str2, 2);
	printf("%s", str1);
	return 0;
}

结果：
sssab

---

1.7 strncmp

int strncmp( const char *string1, const char *string2, 
                                  size_t count );

有长度限制的比较字符串，比较前count后就不会继续比。

使用：

int main()
{
	char* str1 = "abt";
	char* str2 = "abc";
	int ret = strncmp(str1, str2, 2);
	printf("%d", ret);
	return 0;
}

结果：
0

---

1.8 strstr

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

搜索字符串，在string中找子串看有没有strCharSet。找到就返回strCharSet在string中的地址，没找到就返回NULL。

使用：

int main()
{
	char* str1 = "aaaaabc";
	char* str2 = "abc";
	char* ret = strstr(str1, str2);
	if (ret)
	{
		printf("YESn");
	}
	else
	{
		printf("NOn");
	}
	return 0;
}

结果：
YES

---

1.9 strtok

char *strtok( char *strToken, const char *strDelimit );

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

使用：

int main()
{
	char str1[] = "ab.cde.fg";
	char str2[] = ".";
	printf("%sn", strtok(str1, str2));
	printf("%sn", strtok(NULL, str2));
	printf("%sn", strtok(NULL, str2));
	printf("%sn", strtok(NULL, str2));
	printf("%sn", strtok(NULL, str2));
	return 0;
}

结果：
ab
cde
fg
(null)
(null)

---

1.10 strerror

char *strerror( int errnum );

报错函数，返回错误信息。

int main()
{
	//申请超出范围的内存
	int* p = (int*)malloc(INT_MAX * 10);
	if (p == NULL)
	{
		//errno是C语言设置的一个全局错误码存放的变量
		printf("%sn", strerror(errno));
		exit(-1);
	}
	return 0;
}

结果：
Not enough space

---

1.11 memcpy

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

内存拷贝函数，strcmp也是拷贝函数，但他只能拷贝字符串。他是从src的位置拷贝count个字节的数据放到dest对应的位置。
注意：
1）遇到’’不会停下来。
2）不能用memcpy拷贝重叠的内存。

使用：

int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1, 2, 3 };
	memcpy(arr1, arr2, 12);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

结果：
1 2 3 0 0 0 0 0 0 0

---

1.12 memmove

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

他和memcpy的差别是：memmove可以处理重叠区域的拷贝。

使用：

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

结果：
1 2 1 2 3 6 7 8 9 10

---

1.13 memcmp

int memcmp( const void *buf1, const void *buf2, size_t count );

内存比较函数,要注意count不能大于数组。
注意：
1）buf1 > buf2 返回大于0的数字
2）buf1 = buf2 返回等于0的数字
3）buf1 < buf2 返回小于0的数字

使用：

int main()
{
	int arr1[10] = { 1, 8, 3, 4, 5, 6, 7, 8, 9, 10 };
	int arr2[] = { 1, 3, 3, 4, 5, 6, 7, 8, 9, 10 };
	int ret = memcmp(arr1, arr2, 40);
	printf("%dn", ret);
	return 0;
}

结果：
1

---

二、常见库函数模拟实现 2.1 strlen模拟实现

int my_strlen(const char* str)
{
	if (*str == '')
	{
		return 0;
	}
	return 1 + my_strlen(str + 1);
}

---

2.2 strcpy模拟实现

char* my_strcpy(char* dest, const char* sour)
{
	assert(dest && sour);
	char* p = dest;
	while (*dest++ = *sour++)
	{
		;
	}
	return p;
}

---

2.3 strcat模拟实现

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

---

2.4 strstr模拟实现

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* p = str1;
	const char* p1 = str1;
	const char* p2 = str2;
	while (*p)
	{
		p1 = p;
		p2 = str2;
		while (*p1 && *p1 == *p2)
		{
			p1++;
			p2++;
		}
		if (*p2 == 0)
		{
			return p;
		}
		p++;
	}
	return NULL;
}

2.5 strcmp模拟实现

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2 && *str1 != 0)
	{
		str1++;
		str2++;
	}
	return (*str1 - *str2);
}

---

2.6 memcpy模拟实现

void* my_memcpy(const void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	char* p1 = (char*)dest;
	char* p2 = (char*)src;
	while (count--)
	{
		*p1++ = *p2++;
	}
	return ret;
}

---

2.7 memmove模拟实现

void* my_memmove(void* dest, const void* sour, size_t num)
{
	assert(dest && sour);
	void* p = dest;
	if (dest <= sour)
	{
		while (num)
		{
			num--;
			*(char*)dest = *(char*)sour;
			dest = (char*)dest + 1;
			sour = (char*)sour + 1;
		}
	}
	else
	{
		while (num)
		{
			num--;
			*((char*)dest + num) = *((char*)sour + num);
		}
	}
	return p;
}

---

---

暑期编程PK赛 得CSDN机械键盘等精美礼品！