【C语言进阶】字符串和内存函数（上）

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串 中或者 字符数组 中。
字符串常量 适用于那些对它不做修改的字符串函数.

1.strlen

size_t strlen ( const char * str );

1. 字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
2. 参数指向的字符串必须要以 ‘\0’ 结束。
3. 注意函数的返回值为size_t，是无符号的（ 易错 ）

1.1实现

1.2模拟

法一（指针）：

#include<stdio.h>
#include<string.h>

size_t str(const char* arr)
{
	size_t coust = 0;
	while (*arr)
	{
		arr++;
		coust++;
	}
	return coust;
}

int main()
{
	char arr[] = "abcdef";
	size_t ret = str(arr);
	printf("%zd\n", ret);

	return 0;
}

法二（递归）：

size_t str(const char* arr)
{
	assert(arr!=NULL);
	if (*arr != '\0')
		return 1 + str(arr + 1);
	else
		return 0;
}

int main()
{
	char arr[] = "abcdef";
	size_t ret = str(arr);
	printf("%zd\n", ret);

	return 0;
}

法三（指针-指针）

size_t str(char* arr)
{
	assert(arr!=NULL);

	char* p = arr;
	while (*p)
	{
		p++;
	}
	return p - arr;
}


int main()
{
	char arr[] = "abcdef";
	size_t ret = str(arr);
	printf("%zd\n", ret);

	return 0;
}

2.strcpy

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

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

2.1实现

2.1模拟

char* cpy(char* a, const char* b)
{
	assert(a && b);
	char* ret = a;

	while (*a++=*b++)
	{
		;
	}
	return ret;
}


int main()
{
	char a[20] = "xxxxxxxxxxxx";
	char b[20] = "abcd";
	cpy(a, b);
	printf("%s", a);

	return 0;
}

3.strcat

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

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

3.1实现

3.2模拟

char* cat(char* dena,const char* scr)
{
	char* ret = dena;
	assert(dena && scr);
	//找\0
	int num = 0;
	while (*dena)
	{
		dena++;
		num++;
	}

	//追加
	while (*dena++ = *scr++)
	{
		;
	}
	return ret;
}

int main()
{
	char dena[20] = "hello ";
	char scr[] = "world";

	cat(dena, scr);
	printf("%s", dena);

	return 0;
}

4.strcmp

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

• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于0的数字

4.1实现

4.2模拟

int cmp(char* arr1, char* arr2)
{
	assert(arr1 && arr2);

	while (*arr1 && *arr2)
	{
		if (*arr1 == *arr2)
		{
			arr1++;
			arr2++;
		}
		if (*arr1 < *arr2)
		{
			return -1;
		}
		if (*arr1 < *arr2)
		{
			return 1;
		}
	}
	return 0;
}

int main()
{
	char str1[] = "abc";
	char str2[] = "abk";
	int ret=cmp(str1, str2);
	printf("%d", ret);
	return 0;
}

5.strncpy

char * strncpy ( char * destination, const char * source, size_t num );

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

5.1实现

5.2模拟

char* ncpy(char* str1, const char* str2, int n)
{
	char* cp = str1;
	assert(str1 && str2);
	int i = 0;
	for (i = 0; i < n; i++)
	{
		*cp = *str2;
		cp++;
		str2++;
	}
	return str1;
}

int main()
{
	char des[20] = "xxxxxxxxxxxx";
	char scr[] = "hello world";
	int num = 5;
	ncpy(des, scr, num);
	printf("%s", des);

	return 0;
}

6.strncat

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

6.1实现

6.2模拟

char* ncat(char* str1, char* str2, int n)
{
	//找'\0'
	char* cp = str1;
	while (*cp)
	{
		cp++;
	}
	//追加
	int i = 0;
	for (i = 0; i < n; i++)
	{
		*cp = *str2;
		cp++;
		str2++;
	}
	return str1;
}

int main()
{
	char des[20] = "hello ";
	char scr[] = "worldxxxxxxxx";
	int num = 5;

	ncat(des, scr, num);
	printf("%s", des);

	return 0;
}

7.strncmp

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

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

7.1实现

7.2模拟

int ncmp(const char* str1,const char* str2, int num)
{
	assert(str1&&str2);
	int i = 0;
	for (i = 0; i < num; i++)
	{
		if (*str1 == *str2&&*str1&&*str2)
		{
			str1++;
			str2++;
		}
		else if (*str1 > *str2)
		{
			return 1;
		}
		else if (*str1 < *str2)
		{
			return -1;
		}
	}
	return 0;
}

int main()
{
	char des[20] = "abfababc";
	char scr[] = "abcd";
	int num = 3;
	int ret=ncmp(des, scr, num);
	printf("%d", ret);

	return 0;
}

8.strstr

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

• 返回指向 str2 中第一次出现的 str1 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。
• 匹配过程不包括终止空字符，但它到此为止。

8.1实现

8.2模拟

char*rstr(char* str1,char* str2)
{
	assert(str1 && str2);
	if (*str2 == '\0')
	{
		return str2;
	}

	char* s1 = str1;
	char* s2 = str2;
	char* cp = str1;

	while (*s1)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 == *s2 && s1 && s2)
		{
			s1++;
			s2++;
		}
		cp++;
		if (*s2)
		{
			return str2;
		}
	}
	return NULL;

}
int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = rstr(str, "simple");
	if (pch==NULL)
	{
		printf("找不到");
	}
	else
	{
		printf("找到了");
	}
	return 0;
}

9.strtok

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

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

9.1实现

10.strerror

char * strerror ( int errnum );

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