【C语言】字符串与内存

字符串长度

strlen

\0 以前字符的个数

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

strcpy

char* my_strcpy(char* dest, char* src)
{
	assert(dest && src);
	char* tmp = dest;//存放目标地址
	while (*dest++ = *src++)// \0 的ASCII码值为0
	{

	}
	return tmp;
}
int main()
{
	char arr1[20];
	char* arr2 = "abcdef";
	printf("%s", my_strcpy(arr1, arr2));
	return 0;
}

strcat

//strcat   字符串追加
char* my_strcat(char* dest, char* src)//参考代码，有bug，不能自己给自己追加
{
	//1.找源字符串\0
	//2.再把原字符串拷贝带目标空间
	assert(dest && src);
	char* tmp = dest;//存放目标地址
	while (*dest)// \0 的ASCII码值为0
	{
		dest++;
	}
	while (*dest++ = *src++)// \0 的ASCII码值为0
	{}
	return tmp;
}
int main()
{
	char arr1[20] = "Hello\0xxxx";//从\0的位置开始追加
	char arr2[] = "world";
	//strcat(arr1, arr2);
	my_strcat(arr1, arr2);

	printf("%s\n", arr1);
	return 0;
}

注意：自己给自己追加会出错

strcmp

//strcmp   字符串比较
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	//if (*str1 > *str2)
	//	return 1;
	//else
	//	return -1;
	return *str1 - *str2;
}
int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abh";

	//int ret = strcmp(arr1, arr2);
	int ret = my_strcmp(arr1, arr2);
	printf("%d", ret);
	//返回值为 -1( <0 )   0     1( >0 )
	//strcmp函数比较的不是字符串的长度
	//而是比较字符串中对应位置的的字符的大小，若相同，比较下一对儿，直到遇到\0
	return 0;
}

strcmp，strcat，strcpy以上函数的长度不受限制，就会有潜在风险！！！
目标空间不够放
如以下代码：

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdehjmymgvkgk,f";
	strcpy(arr1, arr2);
	return 0;
}

长度受限制的字符串函数

strncpy

strncat

strncmp

此时该函数自己给自己追加，就可以了

---

字符串查找

strstr（字符串中查找字符串）

char* my_strstr(const char* str1, const char* str2)
//判断str2是不是str1中的函数

char* my_strstr(const char* str1, const char* str2)//判断str2是不是str1中的函数
{
	assert(str1 && str2);
	const char* s1 = str1;
	const char* s2 = str2;
	
	const char* cur = str1;
	while (*cur)
	{
		s1 = cur;
		s2 = str2;
		while (*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)cur;
		cur++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "jmymgvkgk";
	char arr2[] = "adejjmymgvkgk,f";
	//char* ret = strstr(arr2, arr1);//返回的是查找字符串的首地址（目标字符串内的），若找不到返回空指针
	char* ret = my_strstr(arr2, arr1);
	if (ret == NULL)
	{
		printf("找不到！！！\n");
	}
	else
	{
		printf("%s\n",ret);
	}
	return 0;
}

strtok（截断输出）

错误信息报告

strerror

字符分类函数

例：

int main()
{
	int ret = islower('A');//判断大小写
	printf("%d", ret);
	return 0;
}

字符转换

char ret1 = tolower(ch);//转换为小写
char ret2 = toupper(ch);//转换为大写

内存操作函数

memcpy

//作者实现memcpy函数的时候
//void* memcpy(void* dest, const void* src, size_t count);//目标    源头    数量（单位：字节）

void* my_memcpy(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;//泛型指针先转换，再解引用
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

注意： 泛型指针先转换，再解引用。
缺点： 不能实现重叠内存的拷贝

memmove

memcpy的升级版
可以实现重叠内存拷贝

void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	//1
	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;
	//2
	//if (dest > src && dest < ((char*)src + count))//偏移量
	//{
	//	//后->前
	//}
	//else
	//{
	//	//前->后
	//}
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1+2, arr1, 20);//可以实现重叠内存的拷贝
	//my_memmove(arr1, arr1+2, 20);//可以实现重叠内存的拷贝
	return 0;
}

memset

内存设置

int main()
{
	int arr[] = { 0x11111111,0x22222222,3,4,5 };
	memset(arr, 6, 20);//memset是以字节为单位来初始化内存单元的   将arr地址开始的前20个字节设置为6
	return 0;
}

memcmp

内存比较

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,3,4,0x11223305 };
	int ret = memcmp(arr1, arr2, 18);//以字节为单位比较
	printf("%d\n", ret);

	return 0;
}