总结一下字符串函数以及自己仿照出相似的my版本

strlen         size_t strlen ( const char * str );

 

1.字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包

含 '\0' )。

2.参数指向的字符串必须要以 '\0' 结束。

3.注意函数的返回值为size_t，是无符号的（ 易错 ）

4.使用引头文件#include<string.h>

#include <stdio.h>
#include<string.h>
int main()
{
const char*str1 = "abcdef";
const char*str2 = "bbb";
if(strlen(str2)-strlen(str1)>0)
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");
}
return 0;
}

下面仿照 strlen 函数写一下 my_strlen 函数:

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
	assert(str);
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}

	return count;
}
int main()
{
	char str[]= { "abcdef" };
	int ret = my_strlen(str);
	printf("%d", ret);
	return 0;
}

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

1.源字符串必须以 '\0' 结束。

2.会将源字符串中的 '\0' 拷贝到目标空间。

3.目标空间必须足够大，以确保能存放源字符串。

4.目标空间必须可变

 

下面仿照 strcpy 函数写一下 my_strcpy 函数：

#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
	assert(str);
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}

	return count;
}
int main()
{
	char str[]= { "abcdef" };
	int ret = my_strlen(str);
	printf("%d", ret);
	return 0;
}

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

1.源字符串必须以 '\0' 结束。

2.目标空间必须有足够的大，能容纳下源字符串的内容。

3.目标空间必须可修改。

4.字符串自己给自己追加，如何？  不行！会陷入循环：

   设想一下如果在一个字符串上操作，' \0 '被覆盖之后会陷入循环，如图

 

 

下面仿照 strcat 函数写一下 my_strcat 函数：

//模拟实现strcat   
//将源字符串的副本追加到目标字符串。目标中的终止空字符被源的第一个字符覆盖，
//并且在目标中由两者串联形成的新字符串的末尾包含一个空字符。目的地和来源不得重叠。
#include<stdio.h>
char* my_strcat( char* arr1,const char* arr2)
{
	char* p = arr1;
	while (*arr1!='\0')
	{
		arr1++;
	}
	while (*arr1++ = *arr2++)
	{
		;
	}
	
	return p;
}
int main()
{
	char arr1[20] = { "abc" };
	char arr2[] = { "bcd" };
	printf("%s", my_strcat(arr1, arr2));
	return 0;
}

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

 

标准规定：

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

第一个字符串等于第二个字符串，则返回0

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

 

下面仿照 strcmp 函数写一下 my_strcmp 函数：

//模拟实现strcmp
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* arr1, const char* arr2)
{
	assert(arr1 && arr2);
	while (*arr1 == *arr2)
	{
		if (*arr1 != 0)
		{
			arr1++;
			arr2++;
		}
		else break;
	}
	int ret= (*arr1 ) - (*arr2);
	if (ret > 0)
	{
		return 1;
	}
	else if (ret == 0)
	{
		return 0;
	}
	else return -1;
}

int main()
{
	char arr1[] = { "abcd" };
	char arr2[] = { "abcd" };
	int ret = my_strcmp(arr1, arr2);
	printf("%d", ret);
	return 0;
}

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

返回指向 str1 中第一次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。匹配过程不包括终止空字符，但它到此为止。

下面仿照 strstr 函数写一下 my_strstr 函数：

//模拟实现strstr   
//返回指向 str1 中第一次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。
//匹配过程不包括终止空字符，但它到此为止。
#include<stdio.h>

char* my_strstr(const char* str1, const char* str2)
{
	const char* s1 = str1;     //把str1的起始地址保存在s1中
	const char* s2 = str2;     //把str2的起始地址保存在s2中
	const char* p = str1;      //把str1的起始地址保存在p中
	if (*str2 == '\0')         //如果str2是空字符串直接返回str1
	{
		return str1;
	}
	while (*p)      //p地址指向的空间不为0
	{
		s1 = p;    //把p指向的地址赋值给s1（这里的p在变化）相当于str1从左到右增加
		s2 = str2; //把str2的地址赋值给s2，因为s2在下面的循环中变了，但是每一次新循环需要重置
		while (*s1!='\0' && *s2!='\0' && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)p;//找到了
		}
		p++;
	}
	return NULL;//找不到子串
}
int main()
{
	char arr1[] = { "adabcdef" };
	char arr2[] = { "abc" };
	char* p = my_strstr(arr1, arr2);
	if (p == NULL)
		printf("找不到");
	else printf("%s\n", p);
	return 0;
}

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

 

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

这个函数在遇到 '\0' 的时候并不会停下来。

如果source和destination有任何的重叠，复制的结果都是未定义的。

 

/* memcpy example */
#include <stdio.h>
#include <string.h>
struct {
  char name[40];
  int age;
} person, person_copy;
int main ()
{
  char myname[] = "Pierre de Fermat";
  /* using memcpy to copy string: */
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;
  /* using memcpy to copy structure: */
  memcpy ( &person_copy, &person, sizeof(person) );
  printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );
  return 0;
}

下面仿照 memcpy 函数写一下 my_memcpy 函数：

//模拟实现memcpy  void * memcpy ( void * destination, const void * source, size_t num );

//将字节数的值从源指向的位置直接复制到目标指向的内存块。
//源指针和目标指针指向的对象的基础类型与此函数无关; 结果是数据的二进制副本。
//该函数不检查源中的任何终止空字符 - 它总是准确地复制字节数。
//为避免溢出，目标和源参数指向的数组大小应至少为字节数，并且不应重叠（对于重叠的内存块，memmove 是一种更安全的方法）。
// 
#include<stdio.h>
#include<assert.h>

void* my_memcpy(void* dest, void* src, size_t num)
{
	void* p = dest;
	assert(dest);
	assert(src);
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return p;
}


int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1,4);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d\n", arr2[i]);
	}
	return 0;
}

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

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

 

/* memmove example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] = "memmove can be very useful......";
  memmove (str+20,str+15,11);
  puts (str);
  return 0;
}

下面仿照 memmove 函数写一下 my_memmove 函数：

//模拟实现memmove  void * memmove ( void * destination, const void * source, size_t num );
//移动内存块
//将字节数的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样，允许目标和源重叠。
//源指针和目标指针指向的对象的基础类型与此函数无关; 结果是数据的二进制副本。
//该函数不检查源中的任何终止空字符 - 它总是准确地复制字节数。
//为避免溢出，目标参数和源参数指向的数组的大小应至少为字节数。
void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest);
	assert(src);
	void* p = dest;
	if (dest < src)//如果目的内存在源内存左边，那么从左到右复制
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1; 
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*) src + num);
		}
	}
	return p;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = my_memmove(arr1, arr1 + 5, 20);
	for (int i = 0; i < 10; i++)
		printf("%d\n", *(p+i));
	return 0;
}