浅析常用字符串函数

浅析常用字符串函数

文章目录

常用字符串函数

字符串长度strlen字符串拷贝strcpy更谨慎的选择：strncpy字符串拼接strcat更安全—strncat字符串比较strcmpstrncmp字符串查找strstr字符串拆解strtok错误报告strerror好用的字符分类函数 内存 *** 作函数

memcpymemmovememcmp

C库提供了多个处理字符串的函数，ANSI C把这些函数的原型放在string.h头文件中。

常用字符串函数 字符串长度strlen

strlen()函数用于统计字符串的长度：

size_t strlen ( const char * str );

我们对这个函数其实已经很熟悉了，但在此要注意的一些情况是：

strlen()函数的返回值为 size_t 类型，其为unsigned int的重定义，为一无符号整型，对此会有迷惑性的代码出现：

#include 
int main()
{
 const char*str1 = "abcdef";
 const char*str2 = "bbb";
 if(strlen(str2)-strlen(str1)>0)
 {
 printf("str2>str1n");
 } 
 else
 {
 printf("srt1>str2n");
 }
 return 0;
}

我们当然看得出来str1的长度大于str2，可是VS下输出结果为：

str2>str1

这是因为strlen()返回值为一无符号整型，两个无符号整型作差仍为无符号整型，故if判断语句中不可能出现负数，因此无论如何都会输出大于0的情况。当然要修正也很容易，不作差直接比较即可。

函数模拟实现：

int my_strlen(const char* arr)
{	
    assert(arr);
	int count = 0;
	while (*arr++)
	{
		count++;
	}
	return count;
}

字符串拷贝strcpy

如果pts1与pts2均为指向字符串的指针：

pts2 = pts1；

上述语句拷贝的是字符串的地址而并非字符串本身，如果希望拷贝整个字符串，就要使用strcpy()函数：

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

这个函数使用起来也较为简单，但要注意几个点：
目标空间必须足够大，起码能容得下源字符串。
否则：

#include 
int main()
{
	 char str1[] = "abcdef";
	 char str2[3] = {0};
	 strcpy(str2, str1); //error！！！！！！！！！！！！！！
	 printf("%s", str2);
	return 0;
}

目标空间必须可以修改。很好理解。你往里边拷贝东西，你总不能让他不能改变吧。当然源字符串肯定不能改变，故我们使用 const 限定符。

strcpy还有两个有用的属性：

第一，其返回类型为char*，该函数返回的是第一个参数的值，即一个字符的地址。

第二，第一个参数不必指向数组的开始。

我们可以利用这有意思的属性来拷贝数组的一部分。

函数模拟实现：

char* my_strcpy(char* des, const char* str)
{
	assert(str && des);
	const char* p = des;
	while (*des++ = *str++)
	{
		;
	}
	return p;
}

更谨慎的选择：strncpy

strcpy()有个问题，它不能检查目标空间是否能容纳源字符串的副本。此时利用strncpy更加安全：

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

该函数的第三个参数，指明可拷贝的最大字符数，当 source 的长度小于 num 时，dest 的剩余部分将用空字节填充。

字符串拼接strcat

strcat()函数接受两个字符串作为参数，该函数把第二个字符串的备份附加在第一个字符串末尾，并把拼接后形成的新字符串作为第一个字符串：

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

与strcpy()一样，其目标字符串必须足够大，起码能容纳下源字符串的内容。而且目标空间必须可以修改。

函数模拟实现：

char* my_strcat(char* des,const char* str)
{
	char* p = des;
	assert(des && str);
	while (*des)
	{
		des++;
	}
	while (*des++ = *str++)
	{
		;
	}
	return p;
}

更安全—strncat

strcat()函数无法检查第一个数组是否容纳第二个字符串。此时跟strncpy()类似，我们可以选择strncat():

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

第三个参数可以限制追加字符的长度，更加保险。

字符串比较strcmp

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

其标准规定：

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

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

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

需要注意的是，返回值仅是”正数“或”负数“，可并没有说返回的一定是1或-1，不要理所当然的认为返回1或-1。进而在程序上出现一些始料未及的bug。

函数模拟实现：

int my_strcmp(const char* e1,const char* e2)
{
	assert(e1 && e2);
	while (*e1 == *e2)
	{
		if (*e1 == 0)
		{
			return 0;
		}
  		e1++;
		e2++;
	}
	return *e1 - *e2;
}

strncmp

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

strcmp()函数比较字符串中的字符，直到发现不同的字符为止，这一过程可能会持续到字符串的末尾。而strncmp()函数在比较时，可以比较到字符不同的地方，也可以只比较到第三个参数指定的字符数处。

字符串查找strstr

char *strstr(const char *haystack, const char *needle)

该函数返回在 haystack 中第一次出现 needle 字符串的位置，如果未找到则返回 null。

其实这个函数很值得我们自己去模拟实现一下。

此为暴力查找实现方案：

char* my_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);
}

可以进一步体会到查找的过程，此外我们可以想想优化的方案——

字符串拆解strtok

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

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

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

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

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

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

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

虽然看起来很麻烦，举个例子就很容易理解：

int main() 
{
    char str[] = "This-is-my-life";
    const char s[2] = "-";
    char* token = NULL;

    
    token = strtok(str, s);

    
    while (token != NULL) 
    {
        printf("%sn", token);
        token = strtok(NULL, s);
    }

    return(0);
}

输出结果为：

This
is
my
life

错误报告strerror

char * strerror ( int errnum );

该函数返回错误码所对应的错误信息。举个例子：

#include 
#include 
#include 

int main ()
{
   FILE *fp;

   fp = fopen("file.txt","r");
   if( fp == NULL ) 
   {
      printf("Error: %sn", strerror(errno));
   }
   
  return(0);
}

我们想打开不存在的文件，肯定会报错，故输出结果为：

Error: No such file or directory

好用的字符分类函数

include

C 标准库的 ctype.h 头文件提供了一些函数，可用于测试和映射字符，这些函数接受 int 作为参数，它的值必须是 EOF 或表示为一个无符号字符。如果参数 c 满足描述的条件，则这些函数返回非零（true）。如果参数 c 不满足描述的条件，则这些函数返回零。

int iscntrl ( int c )  //任何控制字符 

int isspace ( int c )//空白字符：空格‘ ’，换页‘f’，换行'n'，回车‘r’，制表符't'或者垂直制表符'v' 

int isdigit ( int c )//十进制数字 0~9 

int isxdigit ( int c ) //十六进制数字，包括所有十进制数字，小写字母af，大写字母AF 

int islower ( int c ) //小写字母a~z 

int isupper ( int c ) //大写字母A~Z isalpha 字母az或AZ

int isalnum ( int c ) //字母或者数字，az,AZ,0~9 

int ispunct ( int c ) //标点符号，任何不属于数字或者字母的图形字符（可打印） 

int isgraph ( int c ) //任何图形字符 

int isprint ( int c ) //任何可打印字符，包括图形字符和空白字符
   

以及有两个转换函数：

int tolower ( int c );//该函数把大写字母转换为小写字母。
int toupper ( int c );//该函数把小写字母转换为大写字母

内存 *** 作函数 memcpy

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

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

这个函数在遇到 ‘’ 的时候并不会停下来。

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

其与strlen很像但是二者其实区别很大：

strcpy提供了字符串的复制。即strcpy只用于字符串复制，并且它不仅复制字符串内容之外，还会复制字符串的结束符。

memcpy提供了一般内存的复制。即memcpy对于需要复制的内容没有限制，因此用途更广。

自己模拟一遍就懂了：

void* my_memcpy(char* des, const char* str, size_t num)
{
	char* ret = des;
	assert(des && str);
	while (num--)
	{
		*(char*)des = *(char*)str;
		des = (char*)des + 1;
		str = (char*)str + 1;
	}
	return des;
}

但是如果让它去拷贝重叠部分的内存空间就会出问题。这时候我们一般会用memmove来解决重叠部分的内存问题。

memmove

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

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

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

这个函数也很值得我们自己模拟一下：

void* my_memmove (char* des,const char* str,size_t num)
{
	char* ret = des;
	assert(des && str);
	if (str>des)//将源空间起始地址与目标空间起始地址做对比，如果源地址大小高于目标地址
	{
			while (num--)
		{
			*(char*)des = *(char*)str;//从前往后赋值
			des = (char*)des + 1;
			str = (char*)str + 1;
		}
	}
	else
	{
			while (num--)
		{
			*((char*)des+num) = *((char*)str + num);//从后往前赋值
		}
	}
	return ret;
}

画个图解释下：

memcmp

int memcmp(const void *str1, const void *str2, size_t n)

把存储区 str1 和存储区 str2 的前 n 个字节进行比较。

如果返回值 < 0，则表示 str1 小于 str2。如果返回值 > 0，则表示 str1 大于 str2。如果返回值 = 0，则表示 str1 等于 str2。

举个例子：

#include 
#include 

int main ()
{
   char str1[15];
   char str2[15];
   int ret;

   memcpy(str1, "abcdef", 6);
   memcpy(str2, "ABCDEF", 6);

   ret = memcmp(str1, str2, 5);

   if(ret > 0)
   {
      printf("str2 小于 str1");
   }
   else if(ret < 0)
   {
      printf("str1 小于 str2");
   }
   else
   {
      printf("str1 等于 str2");
   }
   
   return(0);
}

运行结果为：

str2 小于 str1