字符串函数

strlen

求字符串长度

size_t strlen ( const char * str );

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

strlen函数的模拟实现

#include<stdio.h>
#include<string.h>
int MyStrlen(const char *str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char str[] = "abcdef";
	printf("%d\n", MyStrlen(str));
	return 0;
}

strcpy

长度不受限制的字符串函数
把一个字符串复制到另一个字符串上
这个函数有返回值，它的作用是为了支持链式表达式
可以求拷贝后字符串的长度

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

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

strcpy模拟实现

char* MyStrpy(char *dest,const char* src)
{
    assert(dest != NULL&&src!=NULL);
	char* p = dest;
	while (*src != 0)
	{
		*dest = *src;
		src++;
		dest++;
	}
	//代码执行到这里，代表src=\0;
	*dest = '\0';
	return p;
}
int main()
{
	char dest[10] = { 0 };
	char* src = "helloabc";
	MyStrpy(dest, src);
	printf("%s\n", dest);
	return 0;
}

strcat

把一个字符串拼接到另一个字符串后面

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

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

strcpy的模拟实现

char* MyStrcat(char* dest,const char *src)
{
	assert(dest != NULL);
	if (src == NULL)
	{
		return dest;
	}
	char* p = dest;
	while (*dest != '\0')
	{
		dest++;
	}
	while (*src != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	*dest = '\0';
	return p;
}
int main()
{
	char dest[20] ="bit";
	char* src = "helloabc";
	MyStrcat(dest, src);
	printf("%s\n", dest);
	return 0;

strcmp

字符串的比较

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

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

strcmp的模拟实现

int MyStrcmp(char* str1,char* str2)
{
	assert(str1 != NULL&&str2!=NULL);
	if (str1 == NULL)return -1;
	if (str2 == NULL)return 1;
	while (*str1 == *str2)
	{
		if (*str1=='\0')
		{
			return 0;
		}
		str1++;
		str2++;		
	}
	if (*str1 > *str2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}
int main()
{
	char* str1 = "abca";
	char* str2 = "abcd";
	int ret = MyStrcmp(str1, str2);
	printf("%d\n", ret);
	return 0;
}

strncpy

长度受限制的字符串函数介绍

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

可以规定拷贝的多少

于此可见，只拷贝了src字符串中两个单词，到dest并覆盖

strncat

可以规定拼接的多少

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

strncmp

可以规定比较的字符多少

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

strstr

字符串查找
在主串中查找子串第一次出现的位置，并且把后面的值都打印出来

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

strstr的模拟实现

char* MyStrstr(char* str1 ,char* str2)
{
	char* start = str1;
	char* s1 = str1;
	char* s2 = str2;
	while (*start != '\0')
	{
		char* s1 = start;
		char* s2 = str2;
		while (*s1 == *s2&& *s1&& *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return start;
		}
		start++;
	}
	return NULL;
}
int main()
{
	char* str1 = "heaabche";
	char* str2 = "abc";
	char* p = MyStrstr(str1, str2);
	printf("%s\n", p);
	return 0;
}

strtok

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

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

strerror

错误信息报告
返回错误码，所对应的错误信息。
内存操作函数

memcpy

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

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

但是有可能发生内存重叠
这种情况下，未定义

memmove

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

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

void Mymemove(void* dest, void* src, int count)
{
	void* ret = dest;
	if (src > dest)
	{
		while (count != 0)
		{
			*(char*)dest = *(char*)src;
			((char*)dest)++;
			((char*)src)++;
			count--;
		}
	}
	else
	{
		count--;
		while (count >= 0)
		{
			*((char*)dest + count) = *((char*)src + count);
			count--;
		}		
	}
	return ret;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8 };
	Mymemove(arr+2, arr, 16);
	for (int i = 0;i < 8; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

这样就可以避免内存的重叠。

memcmp

比较内存里值的大小

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

int main()
{
	char buffer1[] = "DWgaOtP12df0";
	char buffer2[] = "DWGAOTP12DF0";
	int ret = memcmp(buffer1, buffer2, 3);
	printf("%d\n", ret);
	return 0;

int ret = memcmp(buffer1, buffer2, 3);
第3个参数为比较第几个数字