字符函数和字符串函数（总结集合）

目录

求字符串长度

strlen

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

strcpy 

strcat

strcmp

长度受限制的字符串函数

strncpy

strncat

strncmp

字符串查找

strstr

strtok

内存操作函数

memcpy

memmove

---

求字符串长度

strlen

size_t strlen(const char *str)

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

strlen模拟实现：

unsigned int Mystrlen(const char* str)
{
	assert(str != NULL);
	unsigned int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

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

strcpy 

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

1.  源字符串必须以'\0'结束。strcpy函数返回的是将source字符串拷贝到destination字符串中。
2. 会将源字符串中的'\0'拷贝到目标空间。
3. 目标空间必须足够大，以确保能存放源字符串。

strcpy模拟实现:

char *Mystrcpy(char *dest, const char *src)
{
	char *p = dest;
	assert(dest != NULL && src != NULL);
	while (*dest++ = *src++);
	return p;
}

strcat

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

1. 源字符串必须以'\0'结束。strcat函数返回的是将source字符串拼接到destination字符串后边。
2. 目标空间必须足够大，能容下源字符串的内容。 

strcat模拟实现：

char *Mystrcat(char *dest, const char *src)
{
	char *p = dest;
	assert(dest != NULL && src != NULL);
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++);
	return p;
}

strcmp

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

1. strcmp是字符串比较函数。
2. 第一个字符串大于第二个字符串，则返回大于0的数字
3. 第一个字符串等于第二个字符串， 则返回0
4. 第一个字符串小于第二个字符串，则返回小于0的数字

strcmp模拟实现：

int Mystrcmp(const char *str1, const char *str2)
{
	assert(str1 != NULL && str2 != NULL);
	while (*str1 == *str2 )
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	if (*str1 > *str2)
	{
		return 1;
	}
	else 
	{
		return -1;
	}
}

长度受限制的字符串函数

strncpy

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

1.  strncpy函数是拷贝num个字符从source字符串到destination字符串。
2. 如果源字符串的长度小于num,则拷贝完源字符串之后，在目标的后边追加'\0'，直到num个。

strncpy模

拟实现：

char *Mystrncpy(char *dest, const char *src,int n)
{
	int count = 0;
	assert(dest != NULL && src != NULL);
	char *p = dest;
	while (count < n)
	{
		*dest++ = *src++;		
		count++;
	}
	return p;
}

strncat

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

1. strncat是拼接字符串，将source字符串的num个字符拼接到destination字符串中。 

strncat模拟实现 :

char *Mystrncat(char *dest, const char *src, int n)
{
	assert(dest != NULL && src != NULL);
	char *p = dest;
	while (*dest != '\0')
	{
		dest++;
	}
	for (int i = 0; i < n; i++)
	{
		*dest++ = *src++;
	}
	return p;
}

strncmp

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

1. strncmp函数是字符串比较函数，比较前num个字符串。
2. 比较到出现不一样或者一个字符结束或者num个字符全部比较完。
3. 返回值和前边strcmp一样。

strncmp模拟实现:

int Mystrncmp(const char *dest, const char *src, int n)
{
	assert(dest != NULL && src != NULL);
	int count = 0;
	int diff = 0;
	while (count < n &&((diff = (*dest - *src)) == 0) && *dest != '\0')
	{
		dest++;
		src++;
		count++;
	}
	return diff;
}

字符串查找

strstr

char *strstr(const char *,const char *)

1. strstr函数返回的是str2字符串在str1字符串出现的首位置，如果有则从出现在字符串开始打印完第一个字符串，如果无打印null。

strstr模拟实现:

const char *Mystrstr(const char *str1, const char *str2)
{
	const char *s1 = str1;
	const char *s2 = str2;
	const char *start = s1;
	assert(str1 != NULL && str2 != NULL);
	while (*start != '\0')
	{
		s1 = start;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s1 == '\0')
		{
			return NULL;
		}
		if (*s2 == '\0')
		{
			return start;
		}
		start++;
	}
	return NULL;
}

strtok

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

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

内存操作函数

memcpy

void *memcpy(void *destination,const void *source,size_t num)

1.  函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
2. 这个函数在遇到'\0'的时候并不会停下来。
3. 如果source和destination有重叠，则函数不确保在覆盖之前复制重叠区域中的原始原字节。

 memcpy模拟实现：

void* Mymemcpy(void *dest, const void *src, size_t count)
{
	assert(dest != NULL && src != NULL);
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;
		((char*)dest)++;
		((char*)src)++;		
	}
	return (ret);
}

memmove

void *memmove(void *destination,const char *source,size_t num)

1. memmove函数将字符串计数字节从source复制到destination。
2. 如果原区域与目标区域的某些区域重叠，memmove确保在覆盖之前复制重叠区域中的原始原字节

memmove模拟实现：

void* Mymemove(void *dest, const void *src, size_t count)
{
	assert(dest != NULL && src != NULL);
	void* ret = dest;
	if (dest < src)
	{
		while (count--)
		{
			*(char*)dest = *(char*)src;
			((char*)dest)++;
			((char*)src)++;
		}
	}
	else
	{
		while (count--)
		{
			*((char*)dest+count) = *((char*)src+count);
		}
	}
}