字符函数和字符串函数

前言

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

strcat

将两个char类型连接

原型

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

注意

源字符串必须以’\0’结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
char* 说明返回地址，返回的是目标空间的起始地址。

效果

int main()
{
	char str1[100] = "abcde";
	char str2[] = "dce";
	printf("原：%s\n", str1);
	strcat(str1, str2);
	printf("后：%s", str1);
	return 0;
}

模拟实现

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);//利用了assert检测是否为空指针，提高了函数的安全性。
	int sz1= strlen(dest);
	int sz2 = strlen(src);
	int i = 0;
	for (i = 0; i < sz2+1; i++)
	{
		*(dest + i + sz1) = *(src + i);
	}
	return dest;
}

strcpy

strcpy，即string copy（字符串复制）的缩写

原型

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

注意

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

效果

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "fedcba";
	printf("前：%s\n", arr2);
	my_strcpy(arr2, arr1);
	printf("后：%s", arr2);
	return 0;
}

模拟实现

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

strcmp

strcmp函数是string compare(字符串比较)的缩写

原型

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

注意

第一个字符串大于第二个字符串，则返回大于0的数字 第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
即两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇’\0’为止

效果

int main()
{
	char str1[] = "abcde";
	char str2[] = "abcde";
	char str3[] = "abde";
	int flag = strcmp(str1, str2);
	if(flag==0)
	{
		printf("相等\n");
	}
	else
	{
		printf("不相等\n");
	}
	flag = strcmp(str1, str3);
	if (flag == 0)
	{
		printf("相等\n");
	}
	else
	{
		printf("不相等\n");
	}
	return 0;
}

模拟实现

int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while ((*s1) - (*s2) == 0)
	{
		s1++;
		s2++;
		if ((*s1) == '\0' || (*s2) == '\0')
		{
			return (*s1) - (*s2);
		}
	}
	return (*s1) - (*s2);
}

strncpy strncat strncmp

原型

char*strncpy(char*destination,const char*source,size_tnum)
char*strncat(char*destination,const char*source,size_tnum)
int strncmp(const char*str1,constchar*str2,size_tnum)

介绍

与前面的几个函数功能差不多，但可以实现长度

strstr

作用是返回字符串中首次出现子串的地址

原型

charstrstr(constchar,constchar*)

效果

int main()
{
	char str1[] = "abcdefg";
	char str2[] = "cde";
	char str3[] = "acb";
	if ((strstr(str1, str2)) != NULL)
	{
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	if ((strstr(str1, str3)) != NULL)
	{
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	return 0;
}

模拟实现

char* my_strstr(char* str1, const char* str2)
{
	assert(str1 && str2);
	int sz1 = strlen(str1);
	int sz2 = strlen(str2);
	char* p = str1;
	int i = 0;
	int n = 0;
	while (sz1)
	{
		int flag = 1;
		if (*p == *str2)
		{
			for (i = 0; i < sz2 - 1; i++)
			{
				if (*(p + i) != *(str2 + i))
				{
					goto flag;
					break;
				}
				
			}
			return p;
		}
		flag:
		p++;
		sz1--;
	}
	return NULL;
}

strtok

原型

charstrtok(charstr,constchar*sep);
sep参数是个字符串，定义了用作分隔符的字符集合

注意

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

效果

int main()
{
	char str[] = "192.168.1.1";
	printf("%s\n", str);
	char* ret = NULL;
	for (ret = strtok(str, "."); ret != NULL;ret = strtok(NULL,"."))
		printf("%s ", ret);
	return 0;
}

此函数较难模拟实现，就不作模拟实现。

memcpy

原型

voidmemcpy(voiddestination,constvoid*source,size_tnum)
能从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，即从源source中拷贝n个字节到目标destin中

注意

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到’\0’不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

效果

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

模拟实现

void* my_memcpy(void* destin, void* source, unsigned n)
{
	void* ret = destin;
	assert(destin && source);
	while (n)
	{
		*(char *)destin =* (char *)source;
		((char*)destin)++;
		((char*)source)++;
		n--;
	}
	return ret;
}

memove

原型

voidmemmove(voiddestination,constvoid*source,size_tnum);
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

注意

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

效果

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