茶虹

c语言---字符串+内存函数

一、求字符串长度

1.strlen

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

1.strcpy

2.strcmp

3.strcat

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

1.strncpy

2.strncat

3.strncmp

四、字符串查找

1.strstr

2.strtok

五、错误信息报告

strerror

六、字符分类函数：

七、字符转换

八、内存操作函数

1.memcpy

2.memmove

3.memcmp

4.memset（）

九、模拟实现strlen

方式1：

方式2：

方式3：

十、模拟实现strcpy

十一、模拟实现strcat

十二、模拟实现strstr

十三、模拟实现memcpy

一、求字符串长度

1.strlen

size_t strlen ( const char * str );

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

参数指向的字符串必须要以 '\0' 结束。注意函数的返回值为size_t，是无符号的（易错）

下面这个代码就是无符号数的比较答案应该是>

#include 
#include 
int main()
{
	char arr[] = "abcdef";
	int len = strlen(arr);
	printf("%d\n", len);

	if ((int)strlen("abc") - (int)strlen("qwerty") > 0)
	{
		printf(">\n");
	}
	else
	{
		printf("<=\n");
	}
	return 0;
}

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

1.strcpy

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

源字符串必须以 '\0' 结束。会将源字符串中的 '\0' 拷贝到目标空间。

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

int main()
{
	//const char* arr3 = "qwertyuiop";
	//arr1指向的是常量字符串，常量是不可修改的,因此不能用于strcpy去复制
	char arr1[] = "asdnsakhas";
	char arr2[] = "abcdef";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

#include 
#include 
#include 
//strcpy函数返回的是目标空间的起始地址
//strcpy函数的返回类型的设置是为了实现链式访问

char* my_strcpy(char*dest, const char* src)
{
	assert(src && dest);  //assert(src != NULL);  assert(dest != NULL);
	char* ret = dest;
	while(*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = { 0 };
	const char* arr2 = "hello bit";

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

2.strcmp

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

标准规定：

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

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

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

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 my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;//相等
		}

		s1++;
		s2++;
	}
	//不相等
	return *s1 - *s2;
}

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abdc";
	int ret = my_strcmp(arr1, arr2);
	if (ret >0)
	{
		printf(">\n");
	}
	else if (ret == 0)
	{
		printf("== \n");
	}
	else
	{
		printf("<\n");
	}
	printf("%d\n", ret);
	return 0;
}

3.strcat

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

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

目标空间必须可修改。

#include 
#include 
#include 
char* my_strcat(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找目标空间中的\0
	while (*dest)
	{
		dest++;
	}
	//拷贝
	while (*dest++ = *src++)
	{
		;
	}
    return ret;
}
int main()
{
	char arr1[20] = "hello";
	char arr2[] = " bit";
	printf("%s\n", my_strcat(arr1, arr2));	
	return 0;
}

字符串自己给自己追加，如何？

#include 
#include 
#include 

char* my_strcat(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找目标空间中的\0
	while (*dest)
	{
		dest++;
	}
	//拷贝
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr[20] = "bit";
	my_strcat(arr, arr);
	printf("%s\n", arr);

	return 0;
}

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

1.strncpy

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

拷贝num个字符从源字符串到目标空间。如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "qwe";
	strncpy(arr1, arr2, 5);
	printf("%s\n", arr1);
	return 0;
}

2.strncat

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

/* strncat example */
#include 
#include 
int main ()
{
     char str1[20];
     char str2[20];
     strcpy (str1,"To be ");
     strcpy (str2,"or not to be");
     strncat (str1, str2, 6);
     puts (str1);
     return 0;
}

输出结果：To be or not

int main()
{
	char arr1[20] = "abcdef\0XXXXXXXX";
	char arr2[] = "qwe";
	strncat(arr1, arr1, 5);
	printf("%s\n", arr1);
	return 0;
}

输出结果：abcdefabcde 碰到\0就认为是字符串结尾。

3.strncmp

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

比较到出现某个字符不一样或者一个字符串结束或者num个字符全部比较完。

/* strncmp example */
#include 
#include 
int main ()
{
      char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
      int n;
      puts ("Looking for R2 astromech droids...");
      for (n=0 ; n<3 ; n++)
      if (strncmp (str[n],"R2xx",2) == 0)
      {
          printf ("found %s\n",str[n]);
      }
     return 0;
}

输出结果:

Looking for R2 astromech droids...
found R2D2
found R2A6

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdq";
	int ret = strncmp(arr1, arr2, 5);	
	printf("%d\n", ret);
	return 0;
}

四、字符串查找

1.strstr

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

/* strstr example */
#include 
#include 
int main ()
{
      char str[] ="This is a simple string";
      char * pch;
      pch = strstr (str,"simple");
      strncpy (pch,"sample",6);
      puts (str);
      return 0;
}

输出结果是：This is a sample string

#include 
#include 
#include 

char* my_strstr(const char* str1, const char* str2)
{
	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[] = "abbbcdef";
	char arr2[] = "bbc";
	char* ret = my_strstr(arr1, arr2);
	if (NULL == ret)
	{
		printf("找不到子串\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

2.strtok

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

sep参数是个字符串，定义了用作分隔符的字符集合

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

如果字符串中不存在更多的标记，则返回 NULL 指针。

/* strtok example */
#include 
#include 
int main ()
{
      char str[] ="- This, a sample string.";
      char * pch;
      printf ("Splitting string \"%s\" into tokens:\n",str);
      pch = strtok (str," ,.-");
      while (pch != NULL)
     {
        printf ("%s\n",pch);
        pch = strtok (NULL, " ,.-");
     }
      return 0;
}

输出结果：

Splitting string "- This, a sample string." into tokens:
This
a
sample
string

#include 
int main()
{
     char *p = "[email protected]";
     const char* sep = ".@";
     char arr[30];
     char *str = NULL;
     strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
     for(str=strtok(arr, sep); str != NULL; str=strtok(NULL, sep))
     {
         printf("%s\n", str);
     }
}

输出结果：

zhangpengwei
bitedu
tech

五、错误信息报告

strerror

char * strerror ( int errnum );

返回错误码，所对应的错误信息。

全局的变量：errno（错误码）

#include 
#include 
#include 
#include 
#include 

int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	int* p = (int*)malloc(INT_MAX);//想堆区申请内存的   需要添加头文件：#include 
    //malloc函数空间申请失败会返回一个空指针

	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		perror("Malloc");
		return 1;
	}

	return 0;
}

输出结果：

No error
Operation not permitted
No such file or directory
No such process
Not enough space
Malloc: Not enough space

六、字符分类函数：

函数	如果他的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行'\n'，回车‘\r’，制表符'\t'或者垂直制表符'\v'
isdigit	十进制数字 0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z或A~Z
isalnum	字母或者数字，a~z,A~Z,0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

int main()
{
	char ch = 'A';
	putchar(toupper(ch));  //A
	putchar(tolower(ch));  //a
	return 0;
}

七、字符转换

int tolower ( int c );

int toupper ( int c );

/* isupper example */
#include 
#include 
int main ()
{
      int i=0;
      char str[]="Test String.\n";
      char c;
      while (str[i])
      {
        c=str[i];
        if (isupper(c)) 
            c=tolower(c);
        putchar (c);
        i++;
      }
      return 0;
}

八、内存操作函数

1.memcpy

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

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

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

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

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;
}

/* memcpy example */
#include 
#include 
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;
}

2.memmove

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

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

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

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

#include 
#include 
#include 
#include 
#include 
#include 
#include 

void* my_memcpy(void* dest, const void* src, size_t count)
//原数据不需要改变，所以加const修饰src增强代码健壮性
{
	assert(dest && src);  //断言  都不能是空指针
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;//强制类型转换不是永久性的
		dest = (char*)dest + 1;
		//dest是void*类型的必须先强制转换为char*类型之后再加1，最后void*类型可以接受任意类型的指针
		src = (char*)src + 1;
	}

	return ret;
}

void* my_memmove(void* dest, const void*src, size_t count)
{
	assert(dest && src);
	void* ret = dest;

	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;
}

//把1 2 3 4 5 拷贝到3 4 5 6 7的位置
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 0 };
	my_memcpy(arr2, arr1, 20);

	int arr3[10] = { 1,2,3,4,5,6,7,8,9,10 };
	               // 1 2 1 2 3 4 5 8 9 10
	memcpy(arr3+2, arr3, 20);

	//my_memmove(arr3+2, arr1, 20);//可以实现重叠内存的拷贝  把前面的拷贝到后面
	my_memmove(arr3, arr3+2, 20);//可以实现重叠内存的拷贝  把后面的拷贝到前面

	int i = 0;
	int sz = sizeof(arr3) / sizeof(arr3[0]);

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr3[i]);
	}

	return 0;
}