当前位置:网站首页>c语言---字符串+内存函数

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

2022-04-23 15:33:00 茶虹

目录

一、求字符串长度

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 <string.h>
#include <stdio.h>
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 <string.h>
#include <stdio.h>
#include <assert.h>
//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 <string.h>
#include <stdio.h>
#include <assert.h>
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 <string.h>
#include <stdio.h>
#include <assert.h>

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 <stdio.h>
#include <string.h>
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 <stdio.h>
#include <string.h>
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 <stdio.h>
#include <string.h>
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 <string.h>
#include <stdio.h>
#include <assert.h>

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 <stdio.h>
#include <string.h>
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 <stdio.h>
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 <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <stdlib.h>

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 <limits.h>
    //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 <stdio.h>
#include <ctype.h>
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 <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;
}

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

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>

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

 3.memcmp

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

比较从ptr1和ptr2指针开始的num个字节

返回值如下:

/* memcmp example */
#include <stdio.h>
#include <string.h>
int main ()
{
      char buffer1[] = "DWgaOtP12df0";
      char buffer2[] = "DWGAOTP12DF0";
      int n;
      n=memcmp ( buffer1, buffer2, sizeof(buffer1) );
      if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
      else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
      else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
      return 0;
}

 4.memset()

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

 

 九、模拟实现strlen

方式1:

//计数器方式
int my_strlen(const char * str)
{
     int count = 0;
     while(*str)
     {
         count++;
         str++;
     }
     return count;
}

方式2:

//不能创建临时变量计数器
int my_strlen(const char * str)
{
     if(*str == '\0')
         return 0;
     else
         return 1+my_strlen(str+1);
}

方式3:

//指针-指针的方式
int my_strlen(char *s)
{
     char *p = s;
     while(*p != ‘\0’ )
          p++;
     return p-s;
}

十、模拟实现strcpy

//1.参数顺序
//2.函数的功能,停止条件
//3.assert
//4.const修饰指针
//5.函数返回值
//6.题目出自《高质量C/C++编程》书籍最后的试题部分
char *my_strcpy(char *dest, const char*src)
{ 
     char *ret = dest;
     assert(dest != NULL);
     assert(src != NULL); 
     while((*dest++ = *src++))
     {
         ;
     }
     return ret;
}

十一、模拟实现strcat

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

十二、模拟实现strstr

char *  strstr (const char * str1, const char * str2)
{
        char *cp = (char *) str1;
        char *s1, *s2;
        if ( !*str2 )
            return((char *)str1);
        while (*cp)
        {
             s1 = cp;
             s2 = (char *) str2;
             while ( *s1 && *s2 && !(*s1-*s2) )
                  s1++, s2++;
             if (!*s2)
                  return(cp);
             cp++;
        }
        return(NULL);
}

十三、模拟实现memcpy

void * memcpy ( void * dst, const void * src, size_t count)
{
     void * ret = dst;
     assert(dst);
     assert(src);
     /*
      * copy from lower addresses to higher addresses
      */
     while (count--) 
     {
          *(char *)dst = *(char *)src;
          dst = (char *)dst + 1;             
          src = (char *)src + 1;
     }
     return(ret);
}

版权声明
本文为[茶虹]所创,转载请带上原文链接,感谢
https://blog.csdn.net/weixin_51912875/article/details/122750042