常考字符串函数,内存函数总结大全

文章目录

  • 求字符串长度
    • strlen
  • 长度不受限制的字符串函数
    • 1.strcpy
    • 2.strcat
    • 3.strcmp
  • 长度受限制的字符串函数介绍
    • 1.strncpy
    • 2.strncat
    • 3.strncmp
  • 字符串查找
    • 1.strstr
    • 2.strtok
  • 错误信息报告
    • strerror
  • 字符分类函数
  • 内存操作函数
    • 1.memcpy
    • 2.memmove
    • 3.memcmp

求字符串长度

strlen

size_t strlen ( const char * str );

1.字符串已经 ‘\0’ 作为结束标志,strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数(不包含 ‘\0’ )。

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

3.注意函数的返回值为size_t,是无符号的( 易错 )

#include
#include
int main()
{
     
	if (strlen("abc") - strlen("abcdef") > 0)
	{
     
		printf(" > \n");
	}
	else
	{
     
		printf(" < \n");
	}
}
// 输出结果为 > 

由于strlen函数的返回值类型为size_t , 两个无符号整形相减得到的仍是无符号数 , -3被当成无符号数,补码即为原码,最高位为数值位 , 是一个很大的正数,所以输出结果为 >

4.模拟实现

// 第一种
size_t my_strlen(const char* str)
{
     
	assert(str);
	int count = 0;
	while (*str)
	{
     
		count++;
		str++;
	}
	return count;
}
// 第二种
size_t my_strlen(const char* str)
{
     
	assert(str);
	const char* eos = str;
	while (*str)
	{
     
		str++;
	}
	return str - eos;
}
// 第三种
size_t my_strlen(const char* str)
{
     
	assert(str);
	return (*str) ? my_strlen(str + 1) : 0;
}

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

1.strcpy

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

功能:

strcpy函数将strSource(包括终止的空字符)复制到strDestination指定的位置。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠,strcpy的行为是未定义的。

使用:

#include
#include
int main()
{
     
	char arr1[20] = "poiu";
	char arr2[] = "lkj";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
}

注意事项:

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

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

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

4.目标空间必须可变。

5.模拟实现

#include
#include
#include
char* my_strcpy(char* dest, const char* src)
{
     
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++);  // 拷贝字符串,包括'\0'
	return ret;   // 返回目标空间的起始位置
}
int main()
{
     
	char arr1[20] = "poiu";
	char arr2[] = "lkj";
	printf("%s\n", my_strcpy(arr1, arr2));
}
while (*dest++ = *src++);

该代码相当于 *(dest++) = *(src++) ,将*src的内容赋值给 *dest , 然后src++ , dest++ , 循环直到 *src = ‘\0’ , 退出循环

2.strcat

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

功能:

strcat函数将strSource追加到strDestination,并用空字符终止字符串。strSource的初始字符覆盖strDestination的终止空字符。复制或追加字符串时不执行溢出检查。如果源字符串和目标字符串重叠,strcat的行为是未定义的。

注意事项:

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

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

3.目标空间必须可变。

4 .不能自已给自己追加

5 . 模拟实现

#include
#include
#include
char* my_strcat(char* dest, const char* src)
{
     
	assert(dest && src);
	char* ret = dest;
	while (*dest)  //  1.找到目标空间的 \0
	{
     
		dest++;
	}
	while (*dest++ = *src++);  //  2.追加
	return ret;
}
int main()
{
     
	char arr1[20] = "hello ";
	char arr2[] = "world";
	printf("%s\n", my_strcat(arr1, arr2));
}

3.strcmp

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

功能:
strcmp函数按字典顺序比较string1和string2,并返回一个表示它们之间关系的值。

此函数开始比较每个字符串的第一个字符。如果它们彼此相等,那么继续执行比较,直到字符不同或找到终止的空字符为止

标准规定:

第一个字符串大于第二个字符串,则返回大于0的数字
第一个字符串等于第二个字符串,则返回0
第一个字符串小于第二个字符串,则返回小于0的数字

模拟实现

#include
#include
#include
int my_strcmp(const char* str1, const char* str2)
{
     
	assert(str1 && str2);
	while (*str1 == *str2)
	{
     
		if (*str1 == '\0')
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}
int main()
{
     
	int ret = my_strcmp("abcq", "abcd");
	printf("%d\n", ret);
}

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

1.strncpy

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

功能:

strncpy函数将strSource的初始计数字符复制到strDest并返回strDest。如果count小于或等于strSource的长度,则不会将空字符自动附加到复制的字符串中。如果count大于strSource的长度,则目标字符串将填充长度count以内的空字符。如果源字符串和目标字符串重叠,strncpy的行为是未定义的。

模拟实现:

#include
#include
#include
char* my_strncpy(char* dest, const char* src, size_t count)
{
     
	assert(dest && src);
	char* start = dest;
	while (count && (*dest++ = *src++))
	{
     
		count--;
	}
	if (count)
	{
     
		while (--count)
		{
     
			*dest++ = '\0';
		}
	}
	return start;
}
int main()
{
     
	char arr1[10] = "**********";
	char arr2[] = "abc";
	printf("%s\n", my_strncpy(arr1, arr2, 5));
}

若 count 小于或 等于 Strsrc 的长度,则while循环里的两个条件,count会先减为0,退出循环,然后返回 Strdest的地址

若count 大于Strsrc的长度,(*dest++ = *src++)会先变为0,退出循环,因为在判断该表达式为假时,已经将一个’ \0’拷贝到 Strdest中,故接下来只需要循环(count - 1)次 补’ \0 '的操作,然后返回 Strdest的地址.

2.strncat

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

功能:

从字符串追加字符

将源的前num个字符附加到目标,再加上一个终止的空字符。

如果source中的C字符串长度小于num,则只复制到终止空字符之前的内容。

模拟实现

#include
#include
#include
char* my_strncat(char* dest, const char* src, size_t count)
{
     
	assert(dest && src);
	char* start = dest;
	while (*dest)
	{
     
		dest++;
	}
	while (count--)
	{
     
		if ((*dest++ = *src++) == 0)
			return start;
	}
	*dest = '\0';
	return start;
}
int main()
{
     
	char arr1[20] = "hello \0******";
	char arr2[] = "world";
	printf("%s\n", my_strncat(arr1, arr2, 5));
}

3.strncmp

int strncmp( const char *string1, const char *string2, size_t count );

功能:

比较两个字符串的字符

比较C字符串str1和C字符串str2的最多count个字符。

此函数开始比较每个字符串的第一个字符。如果它们彼此相等,则继续比较,直到字符不同,直到到达一个终止的空字符,或者直到两个字符串中的count字符匹配为止,以先发生的为准。

使用:

#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]);
		}

	}
}

字符串查找

1.strstr

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

功能:

返回指向str1中第一个出现的str2的指针,如果str2不是str1的一部分,则返回空指针。

使用:

#include 
#include 
int main()
{
     
	char str[] = "This is a simple string";
	char* pch = strstr(str, "simple");
	strncpy(pch, "sample", 6);
	puts(str);
}
// 输出结果为
// This is a sample string

模拟实现:

#include 
#include 
#include
char* my_strstr(const char* s1, const char* s2)
{
     
	assert(s1 && s2);
	if(*s2 == '\0')
		return (char*)s1;
	const char* cp = s1;
	while (*cp)
	{
     
		const char* p1 = cp;
		const char* p2 = s2;
		while ((*p1) && (*p2) && (*p1 == *p2))
		{
     
			p1++;
			p2++;
		}
		if (*p2 == '\0')
			return (char*)cp;
		cp++;
	}
	return NULL;
}
int main()
{
     
	char arr1[] = "abbbcdef";
	char arr2[] = "bcd";
	char* ret = my_strstr(arr1, arr2);
	if (ret != NULL)
	{
     
		printf("%s\n", ret);
	}
	else
	{
     
		printf("找不到字串\n");
	}
}

2.strtok

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

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

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

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

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

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

使用:

#include
#include
int main()
{
     
	char arr1[] = "[email protected]";
	char arr2[30] = {
      0 };
	strcpy(arr2, arr1);
	char* p = "@.";
	char* ret = NULL;
	for (ret = strtok(arr2, p); ret != NULL; ret = strtok(NULL, p))
	{
     
		printf("%s\n", ret);
	}
}
// 打印结果
// luanyiping
// 33492586487
// com

错误信息报告

strerror

char *strerror( int errnum );

功能:

strerror函数将errnum映射到错误消息字符串,并返回指向该字符串的指针

使用:

常考字符串函数,内存函数总结大全_第1张图片库函数在使用时,如果发生错误,都会有对应的错误码,这些错误码会被存放在一个全局变量 errno中,使用时需要引用 #include

#include  
#include  
#include  // 必须包含的头文件
int main () 
{
      
 	FILE * pFile; 
	pFile = fopen ("unexist.ent","r"); 
 	if (pFile == NULL) 
       printf ("Error opening file unexist.ent: %s\n",strerror(errno)); 
    //errno: Last error number
    return 0;
}

字符分类函数

常考字符串函数,内存函数总结大全_第2张图片字符转换:

int tolower(int c);
int toupper(int c);

使用:

#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 *dest, const void *src, size_t count );

功能:

memcpy函数将src的count字节复制到dest。如果源和目标重叠,此函数不能确保在覆盖之前复制重叠区域中的原始源字节。使用memmove处理重叠区域。

模拟实现:

#include 
#include 
#include
void* my_memcpy(void* dest, const void* src, size_t count)
{
     
	assert(dest && src);
	void* start = dest;
	while (count--)
	{
     
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return start;
}
int main()
{
     
	int arr1[] = {
      1,2,3,4,5,6 };
	int arr2[] = {
      0 };
	my_memcpy(arr2, arr1, 16);
}

2.memmove

void *memmove( void *dest, const void *src, size_t count );

功能:

memmove函数将count字节的字符从src复制到dest。如果源区域和目标区域的某些区域重叠,memmove将确保在覆盖之前复制重叠区域中的原始源字节。

模拟实现:

#include 
#include 
#include
void* my_memmove(void* dest, const void* src, size_t count)
{
     
	assert(dest && src);
	void* start = dest;
	if (dest < src)
	{
     
		// 从前向后拷贝
		while (count--)
		{
     
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
	}
	else
	{
     
		// 从后向前拷贝
		while (count--)
		{
     
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return start;
}
int main()
{
     
	int arr[] = {
      1,2,3,4,5,6,7,8,9,10};
	my_memmove(arr + 2,arr,16);
}

3.memcmp

int memcmp( const void *buf1, const void *buf2, size_t count );

功能:

memcmp函数比较buf1和buf2的第一个计数字节,并返回一个指示它们之间关系的值。

使用:

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

你可能感兴趣的:(字符串,c语言)