字符串库函数

strcpy与strncpy函数

strcpy

strcpy的 函数参数 char *strcpy(char* dest, const char *src);

strcpy 函数的作用是 拷贝字符串 会把原字符串的\0也会传过去 源字符串必须包含\0

strcpy 函数必须保证 目标空间 必须比 源字符串空间大  保证目标空间可以修改

int main()
{
	char arr[1000];
	char arr1[20];
	//char arr2[] = "abcdef";//常量字符串 - 无法改变
	gets(arr);
	//strcpy - 拷贝字符串 会把原字符串的\0也会传过去 源字符串必须包含\0
	// 目标空间 必须比 源字符串空间大 
	// 保证目标空间可以修改
	//strcpy(arr2, arr);
	printf("%s", strcpy1(arr1,arr));
	return 0;
}

strcpy的模拟实现

char * strcpy1(char* arr1, const char* arr)//因为只是传 不能改变源字符串 所以要 把他锁住
{
	char* ret = arr1;
	assert(arr1 && arr);
	while (*arr1++ = *arr++)//每次赋值之后 再++ //拷贝到 \0 为假 跳出循环
	{
		;
	}
	return ret; //返回目标空间起始地址

strncpy

strncpy的 函数参数 char *strncpy(char *destinin, char *source, int maxlen)

strncpy - 字符串拷贝 可限制长度 如果源数组长度不够 补\0

strncpy 函数必须保证 目标空间 必须比 源字符串空间大  保证目标空间可以修改

int main()
{
	char arr[10] = { "abc\0xxxxxx" };
	char arr1[] = { "ab" };
	printf("%s",strncpy1(arr, arr1, 5));//strncpy - 字符串拷贝 可限制长度 如果源数组长度不够 补\0

模拟实现strncpy

char * strncpy1(char* dest, const char* s1,size_t sz)
{
	assert(dest && s1);
	char * ret = dest;
	while (sz--)
	{
		*dest++ = *s1++;
	}
	return ret;
}

strcat与strncat

strcat

strcat 的函数参数 extern char *strcat(char *dest, const char *src)

strcat 字符追加

strcat 

目标空间得有\0(从哪里开始追加) 源头字符串也要有\0(追加什么时候结束)

目标空间够大,目标可以修改
不建议自己追加自己

strcat 使用

int main()
{
	char arr[20] = "hello ";
	char* p = "world";
	//strcat(arr, p);
	//strcat(arr, "world");
	strcat1(arr, p);
	printf("%s", arr); 
	return 0;
}

模拟实现 strcat

char* strcat1(char* arr, const char* p)
{
	char* ret = arr;
	assert(arr && p);
	//调到末尾
	while (*arr != '\0')
	{
		arr++;
	}
	//拷贝数据
	while (*arr++ = *p++)
	{
		;
	}
	return ret;
}

strncat

strncat 函数参数 char * strncat(char *dest, const char *src, size_t   n)

strncat 字符串追加 可限制长度  如果源数组长度不够 补\0

strncat 使用

int main()
{
	char arr[10] = { "abc\0xxxxxx" };
	char arr1[] = { "ab" };
	printf("%s",strncpy1(arr, arr1, 5));//strncpy - 字符串拷贝 可限制长度 如果源数组长度不够 补\0
	printf("%s",strncat1(arr, arr1, 5));//strncat - 字符串追加 可限制长度  如果源数组长度不够 补\0
	//strncmp(arr, arr1, 5);//strncmp - 字符串比较 可限制长度 
	return 0;
}

模拟实现 strncat

char* strncat1(char* arr, const char* arr1, size_t sz)
{
	assert(arr && arr1);
	char* ret = arr;
	while (*arr)
	{
		*arr++;
	}
	while (sz--)
	{
		*arr++ = *arr1++;
	}
	return ret;
}

strcmp与strncmp

strcmp

strcmp 函数参数 extern int strcmp(const char *s1,const char *s2)

strcmp 比较2个字符串大小 -逐个元素比较

strcmp使用

int main()
{
	//strcmp 比较2个字符串大小 -逐个元素比较
	printf("%d\n", strcmp1("abcdef", "abd"));
	return 0;
}

模拟实现 strcmp

char* strcmp1(char* a1, char* a2)
{
	while (*a1==*a2)
	{
		if (*a1 == '\0')
			return 0;
		a1++;
		a2++;
	}
	if (*a1 > *a2)
	{
		return 1;
	}
	if(*a1<*a2)
		return -1;
}

strncmp

strncmp 函数参数 int strncmp(const char *str1, const char *str2, size_t n)

strncmp - 字符串比较 可限制长度 

int main()
{
	char arr[10] = { "abc\0xxxxxx" };
	char arr1[] = { "ab" };

	strncmp(arr, arr1, 5);//strncmp - 字符串比较 可限制长度 
	return 0;
}

strncmp的模拟实现

int strncmp1(char* a1, char* a2,size_t n)
{
	while (*a1 == *a2 && n)
	{
		if (*a1 == '\0')
			return 0;
		a1++;
		a2++;
		n--;
	}
	if (*a1 > *a2)
	{
		return 1;
	}
	if(*a1<*a2)
		return -1;
}

int main()
{
	//strcmp 比较2个字符串大小 -逐个元素比较
	printf("%d\n", strncmp1("abcdef", "abb",3));
	return 0;
}