字符函数和字符串函数

求字符串长度函数

strlen

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

strcpy

strcat

strcmp

长度受限制的字符串函数

strncpy

strncat

strncmp

字符串查找

strstr

strtok

错误信息报告

strerror

内存操作函数

memcpy

memmove

memset

memcmp

strlen

以'\0'为结束字符串累计个数的标志(不包括\0),strlen返回类型是size_t,是无符号整数类型

size_t strlen(const char* str);

模拟strlen

//模拟strlen
size_t  my_strlen(const char* arr) {
	int count = 0;
	while (*arr != '\0') {
		count++;
		arr++;
	}
	return count;
}
int main() {
	char arr[] = "abcdef";
	printf("%zu",my_strlen(arr));
}

strcpy

拷贝到目标字符串时，源字符串必须以'\0'为结束标志，且源字符穿中的’\0'会拷贝到目标字符串中去，目标空间必须足够大，至少比源字符串的空间大，且目标空间要可变

char* strcpy(char* dest, const char* scr)；

模拟strcpy

//模拟strcpy
#include <assert.h>
char* my_strcpy(char* dest, const char* src) {
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++) {
		;
	}
	return ret;
}
int main() {
	char arr1[20] = "hello";
	char arr2[] = "world";
	printf("%s",my_strcpy(arr1, arr2));
	return 0;
}

strcat

源字符串必须以'\0'结束，目标空间必须足够大得以容纳链接的内容，且可修改，不能自己给自己追加内容。

char* strcat(char* dest, const char* scr)；

模拟strcat

char* my_strcat(char* dest, const char* scr) {
	assert(dest && scr);
	char* ret = dest;
	while (*dest) {
		dest++;
	}
	while ((*dest++ = *scr++)){
		;
	}
	return ret;
}
int main() {
	char arr1[20] = "hello ";
	char arr2[] = "world";
	printf("%s",my_strcat(arr1, arr2));
	return 0;
}

strcmp

是比较两个字符串中每个对应字符的大小,如果第一个字符串大于第二个字符串，则返回大于0的数字，第一个字符串等于第二个字符串，则返回0，第一个字符串小于第二个字符串，则返回小于零的数字。

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

模拟strcmp

#include <assert.h>
int my_strcmp(const char* arr1, const char* arr2) {
	assert(arr1 && arr2);
	while(*arr1 == *arr2) {
		if (*arr2 == 0) {
			return 0;
		}
		arr1++;
		arr2++;
	}
	if ((arr1 - arr2) > 0)
		return 1;
	if ((arr1 - arr2) < 0)
		return -1;
}
int main() {
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	printf("%d",my_strcmp(arr1, arr2));
	return 0;
}

strncpy

char* strncpy(char* dest,const char* src,size_t num);

num表示从源字符串中拷贝字符的个数，如果拷贝的字符个数大于目标空间本来的内存大小，目标空间应追加到能放进num个字符为止。

strncat

char* strncat(char* dest,const char* src,size_t num);

num表示从源字符串中链接到目标空间的字符个数，如果链接的字符个数大于目标空间本来的内存大小，目标空间应追加到能放进num个字符为止。

strncmp

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

num表示两组字符串中各个字符相比较的个数，返回值的标准与strcmp类似。

strstr

从要搜寻的字符串中一个个匹配目标字符串，如果要搜寻的字符串的第一个字符与目标字符相等，则两组字符一个个往后开始匹配，如果出现不匹配的字符串，则要搜寻的字符串从上一次匹配上的字符的下一个地址开始与目标字符串的第一个字符开始匹配，如果在要搜寻的字符串中找到目标字符，则会返回到此次匹配上的第一个字符的地址，如果找不到子串，会返回空指针。

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

模拟strstr

#include <stdio.h>
#include<assert.h>
char* my_strstr(const char* arr1, const char* arr2) {
	assert(arr1 && arr2);
	const char* str1 = arr1;
	const char* str2 =arr2;
	const char* cur = arr1;
	while (*cur){
		str1 = cur;
		str2 = arr2;
		while ((*str1 == *str2) && *str2 && *str1) {
			str1++;
			str2++;
		}
		if (*str2 == '\0') {
			return (char*)cur;
		}
		cur++;
	}
	return NULL;
}
int main() {
	char arr1[20] = "jsfddslvoj";
	char arr2[] = "dsl";
	char* ret=my_strstr(arr1, arr2);
	if (ret==NULL) {
		printf("找不到子串");
	}
	else {
		printf("%s\n",ret);
	}
	return 0;
}

strtok

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

sep是定义分割str字符串的分隔符字符串。

strtok找到str中的分割字符时，strtok函数将返回第一个分割的字符串部分的地址，并将分割的字符串中的标记用\0结尾（注：str会改变被操作的字符串，所以在使用strtok前要先拷贝一份被操作字符串，使用该函数分割字符串都是临时拷贝的内容，可修改）

strtok函数的第一个参数不能是NULL，strtok函数找到第一个标记时会保存它在字符串的位置，如果函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。当被操作字符串不存在更多的标记，则返回NULL

使用strtok的例子

#include <string.h>
int main() {
	char* p = "mmm@qq.com";
	const char* sep = "@.";
	char arr[40];
	//将p字符串拷贝到arr中
	strcpy(arr, p);
	for (char* str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep)) {
		printf("%s\n", str);
	}
	return 0;
}

 strerror

返回错误码所对应的信息

char* strerror(int errnum);

memcpy

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

num表示函数memcpy从src拷贝字节的总数，并不会在遇上'\0'时停下，如果要拷贝的字节多于src中的字节会出现重复拷贝，memcpy不能拷贝数据到同一个空间中。

模拟memcpy

void* memcpy(void* dst, const void* src, size_t count) {
	void* ret = dst;
	assert(dst && src);
	while (count--) {
		*(char*)dst = *(char*)src;
		dst = (char*)dst + 1;
		src = (char*)src + 1;
	}
	return(ret);
}

memmove

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

memmove可以在memcpy的的基础上实现空间的重叠，也就是把本身的数据按要求拷贝到自身

模拟memmove 

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

memcmp

int memcmp(const void* ptr1,const void* ptr2,size_t num);

num表示ptr1和ptr2指针开始比较的字节总数。

如果ptr1>ptr2，则返回大于0的数字,ptr1==ptr2，则返回0，ptr1<ptr2，则返回小于零的数字。