字符串和内存函数

函数介绍

1.strlen是计算字符串长度的

const char *string是为了防止指针被改变，计算是不改变指针内容的

我们来自己模拟实现一下。

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

assert是为了防止str是空指针。

但是再看上图，size_t->unsigned int。但是这样就有弊端了

例如：

#include<string.h>
int main()
{
	if (strlen("abcd") - strlen("abcdefg") > 0)
		printf(">");
	return 0;
}

这样就显得十分不合理，我计算的只是长度，但是返回的是无符号整型。

所以在使用strlen的时候一定要注意

长度不受限制的字符串函数
strcpy
strcat
strcmp
 

---

我们先了解strcpy的使用：

int main()
{
	char arr1[] = "abcdefg";
	char arr2[20] = {0};
	strcpy(arr2, arr1);
	printf("%s", arr2);
	return 0;
}

strcpy（arr2，arr1）;

目的就是把arr1拷贝到arr2;

同时，源字符串必须以'\0'作为结束。

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

我们在模拟实现的时候必须注意这些要点。

//1.参数顺序
//2.函数的功能，停止条件
//3.assert
//4.const修饰指针
//5.函数返回值
char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while ((*dest++ = *src++))
	{
		;
	}
	return ret;
}

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

int main()
{
	char arr1[20] = "hello";
	char arr2[20] = "byte";
	strcat(arr1, arr2);
	printf("%s", arr1);
	return 0;
}

我们可以了解到我们是把arr2的内容加到arr1中。

在这里我们还是可以模拟实现一下：

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;
}

strcmp

我们通过文献可以知道，这里strcmp比较的是字符串的大小。

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "bbc";
	int ret = strcmp(arr1, arr2);
	printf("%d", ret);
	return 0;
}

我们可以找到规律，strcmp比较的是相应位置上的大小。

比如arr1中的arr2比较就是先比a和b,比a大就返回-1，如果相等，则进行下一个字符的比较，如果最后所有字符都相同就返回0.

int my_strcmp(const char* src, const char* dst)
{
	int ret = 0;
	assert(src != NULL);
	assert(dst != NULL);
	while (!(ret = *(unsigned char*)src - *(unsigned char*)dst) && *dst)
		++src, ++dst;
	if (ret < 0)
		ret = -1;
	else if (ret > 0)
		ret = 1;
	return(ret);
}

strncpy

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

int main()
{
	char arr1[] = "xxxxxxxxxxxxxxxxx";
	char arr2[] = "he";
	strncpy(arr1, arr2, 5);
	printf("%s", arr1);
	return 0;
}

strstr

 我们看见这个介绍，就是找一个子串。

就是在string里面找到子串，找到了就把子串的起始地址返回，如果没找到就返回一个空指针。 

int main()
{
	char arr1[] = { "abcdefg" };
	char arr2[] = { "bcd" };
	char* ret = strstr(arr1, arr2);
	if (NULL == ret)
	{
		printf("没找到\n");
	}
	else
		printf("找到了\n");
	return 0;
}

char* strstr(const char* str1, const char* str2)
{
	char* cp = (char*)str1;
	char* s1, * s2;
	if (!*str2)
		return((char*)str1);
	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;
		while (*s1 && *s2 && !(*s1 - *s2))
			s1++, s2++;
		if (!*s2)
			return(cp);
		cp++;
	}
	return(NULL);
}

strtok

 sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标
记

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

---

strtok函数找第一个标记的时候，函数的第一个参数不是NULL

strtok函数找非第一个标记的时候，函数的第一个参数是NULL

#include<stdio.h>
#include<string.h>
int main()
{
	const char* p = "@.";
	char arr[] = "dfjeijcsdu@dnv.net";
	char buf[50] = { 0 };
	strcpy(buf, arr);
	char* str = strtok(buf, p);
	printf("%s\n", str);
	str = strtok(NULL, p);
	printf("%s\n", str);
	str = strtok(NULL, p);
	printf("%s\n", p);
	return 0;
}

但是这个方法使用起来还是太麻烦了，可以说是十分搓的了。

int main()
{
	char arr[] = {"ckdjnvjf#ssdljvnxfj.cnjfsd"};
	const char* p = "#.";
	char buf[60] = { 0 };
	strcpy(buf, arr);
	char* str = NULL;
	for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
	{
		printf("%s\n", str);
	}
	return 0;
}

这样改进，巧妙的运用了for循环。

strsrror

 这个函数实际上是返回错误码，所对应的错误信息。

#include<string.h>
int main()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%s\n",strerror(i));
	}
	return 0;
}

---

 strcpy是只能适用于字符串，但是当我们遇到int类型的数组，那么strcpy就无能为力了。

我们在这里就能运用到内存操作函数。

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

memcpy是什么都能拷贝。

void* memcpy(void* dst, const void* src, size_t count)
{
	void* ret = dst;
	assert(dst);
	assert(src);
	/*
	* copy from lower addresses to higher addresses
	*/
	while (count--) {
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return(ret);
}

 我们先来看看memcpy的缺点

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

当，内存重叠的时候，我们就不能用memcpy.

这个时候我们就应该用memmove去处理重叠内存拷贝。

void* memmove(void* dst, const void* src, size_t count)
{
	void* ret = dst;
	if (dst <= src || (char*)dst >= ((char*)src + count)) {
		/*
		* Non-Overlapping Buffers
		* copy from lower addresses to higher addresses
		*/
		while (count--) {
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else {
		/*
		* Overlapping Buffers
		* copy from higher addresses to lower addresses
		*/
		dst = (char*)dst + count - 1;
		src = (char*)src + count - 1;
		while (count--) {
			*(char*)dst = *(char*)src;
			dst = (char*)dst - 1;
			src = (char*)src - 1;
		}
	}
	return(ret);
}