字符串操作函数和内存函数详解

字符串操作函数的实现

1.strlen函数
函数功能：
计算指定的字符串string的长度。
应用

int main()
{
	char* str = "abcdef";
	printf("%d\n",strlen(str));
	return 0;
}

模拟实现strlen函数
1.计数器实现

#include<stdio.h>
#include<assert.h>
int my_strlen(const char*str)//字符串长度是不变的，用const修饰
{
    assert(str!=NULL);//assert断言
	int ret = 0;
	while (*str!='\0')
	{
		ret++;
		str++;
	}
	return ret;
}
int main()
{
	char* str = "abcdef";
	printf("%d\n",my_strlen(str));
	return 0;
}

2.递归实现

#include<Stdio.h>
int my_strlen(const char* str)
{
	assert(str != NULL);
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}
int main()
{
	char* str = "hello bite";
	int len = my_strlen(str);
	printf("%d\n", len);
	return 0;
}

3.指针-指针实现
指针-指针的结果是中间元素的个数.

#include<stdio.h>
int my_strlen(const char* str)
{
	assert(str != NULL);
	const char*start = str;//存放起始位置
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}
int main()
{
	char* str = "abcdef";
	printf("%d\n",my_strlen(str));
	return 0;
}

2.strcpy函数
函数功能：把含有’\0’结束符的字符串复制到另一个字符串中。
函数原型

	char *strcpy( char *Destination, const char *Source );

模拟实现strcpy函数

char* my_strcpy(char*arr1, const char*arr2)
{
	assert(arr1&&arr2);
	char*ret = arr1;
	while (*arr1++ = *arr2++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "****************";
	char arr2[] = "hello bit";
	char* ret=my_strcpy(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}

3.strcat函数
功能：追加字符串
注意：追加的空间足够大并且可修改
应用：

#include<stdio.h>
int main()
{
	char arr1[20] = "hello";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

模拟实现strcat函数

#include<stdio.h>
#include<assert.h>
 char *my_strcat(char*dest, const char*src)
{   //1.找到目标空间的\0
	//2.追加
	assert(dest&&src);
	char*ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[20] = "hello";
	char arr2[] = "world";
	

4.strcmp函数
功能：字符串的比较。
注意：比较的是对应位置字符的ASCII码值而不是长度。
模拟实现strcmp函数

int my_strcmp(const char*s1, const char*s2)
{
	assert(s1&&s2);
	while (*s1==*s2)
	{
		if (*s1 == '\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	if (*s1 > *s2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}
int main()
{
	char *p = "abcdef";
	int ret = my_strcmp("abq", "abcdef");
	printf("%d\n", ret);
	return 0;
}

5.strstr
功能：在一个字符串中找子字符串。
应用：

int main()
{
	char arr1[] = "abcdefghi";
	char arr2[] = "bcd";
	char *ret=strstr(arr1, arr2);//在arr1中找arr2字符串第一次出现的位置
	if (ret != NULL)
	{
		printf("%s\n", ret);
	}
	else
		printf("找不到字符串\n");
	return 0;
}

模拟实现strstr函数

char *my_strstr(const char*s1, const char*s2)
{
	char*cp = s1;
	while (*cp)
	{
		char*p1 = cp;
		char*p2 = s2;
		while ((*p1!='\0')&&(*p1 == *p2)&&(*p1==*p2))
		{
			p1++;
			p2++;
		}
		if (*p2 == '\0')
		{
			return (char*)cp;
		}
		cp++;
	}
	return NULL;
}

6.strtok

char *strtok( char *strToken, const char *strDelimit );

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

char *strerror( int errnum );

功能：
strerror函数将errnum映射到错误消息字符串，并返回指向该字符串的指针
应用：

#include<errno.h>
int main()
{
	FILE*pf=fopen("test.txt","r");//file open
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
	}
	return 0;
}

字符分类函数

内存操作函数

1.memcpy

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

功能:

memcpy函数将src的count字节复制到dest。如果源和目标重叠，此函数不能确保在覆盖之前复制重叠区域中的原始源字节。使用memmove处理重叠区域。
应用：

#include<stdio.h>
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, 16);
	return 0;
}

模拟实现memcpy函数

#include<stdio.h>
#include<assert.h>
void my_memecpy(void*dest, const void *src, size_t count)
{
	void *ret = dest;
	assert(dest&&src);
	while (count--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 16);
	return 0;
}

2.memmove函数

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

功能:

memmove函数将count字节的字符从src复制到dest。如果源区域和目标区域的某些区域重叠，memmove将确保在覆盖之前复制重叠区域中的原始源字节。
应用：

void test3()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	memeove(arr + 2, arr, 16);
}
int main()
{
	test3();
	return 0;
}

模拟实现memmove

#include <stdio.h>
#include <string.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* start = dest;
	if (dest < src)
	{
		// 从前向后拷贝
		while (count--)
		{
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
	}
	else
	{
		// 从后向前拷贝
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return start;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10};
	my_memmove(arr + 2,arr,16);
}

3.memset函数
memset是初始化函数。作用是将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作。
应用：

int main()
{
    int arr[10]={0};
    memset(arr,1,40);
    return 0;
}

4.memcmp函数
功能：是把存储区 str1 和存储区 str2 的前 n 个字节进行比较。
如果返回值 < 0，则表示 str1 小于 str2。
如果返回值 > 0，则表示 str2 小于 str1。
如果返回值 = 0，则表示 str1 等于 str2。
应用：

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };
	int arr2[] = { 1, 2, 5, 6, 7 };
	int ret=memcmp(arr1, arr2, 8);
	return 0;
}