C语言进阶篇之字符函数和字符串函数（含模拟实现库函数）

本篇主要整理了C语言字符函数和字符串函数的介绍，使用，以及库函数的模拟，持续更新中。

老铁们，整理不易，创作不易，先赞后看养成习惯，你的支持是对我更新最大的鼓励！

函数介绍与模拟实现

1.1 strlen

求字符串长度

size_t strlen ( const char * str );

注：

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

（不包含 '\0' )。
2.参数指向的字符串必须要以 '\0' 结束。
3.注意函数的返回值为size_t，是无符号的（ 易错 ）
4.学会strlen函数的模拟实现

模拟实现strlen函数(3种方法)本文只给出模拟函数部分，主函数部分自己动手补齐，下同

方法一：

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

方法二：

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

方法三：

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

1.2 strcpy

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

注:

1.源字符串必须以 '\0' 结束。
2.会将源字符串中的 '\0' 拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
3.目标空间必须可变。
4.学会模拟实现。

模拟实现库函数strcpy

char *my_strcpy(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);

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

1.3 strcat

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

注：

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

 模拟实现库函数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;
}

1.4 strcmp

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

注：
1.第一个字符串大于第二个字符串，则返回大于0的数字
2.第一个字符串等于第二个字符串，则返回0
3.第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现库函数strcmp

int my_strcmp (const char * src, const char * dst)
{
       int ret = 0 ;
assert(src != NULL);
 
assert(dest != NULL);
       while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
               ++src, ++dst;
       if ( ret < 0 )
               ret = -1 ;
       else if ( ret > 0 )
               ret = 1 ;
       return( ret );
}

1.5 strncpy、strncat 、strncmp

strncpy

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

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

strncat

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

/* strncat example */
//strncat引例
#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;
}

strncmp

int strncmp ( const char * str1, const char * str2, size_t 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;
}

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

模拟实现库函数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);
	}

1.7 strtok

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

解释:

1.sep参数是个字符串，定义了用作分隔符的字符集合
2.第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

3.strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。注：
1.strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。
2.strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
3.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
4.如果字符串中不存在更多的标记，则返回 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;
}

1.8 strerror

char * strerror ( int errnum );

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

1.9 memcpy

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

注：

1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
2.这个函数在遇到 '\0' 的时候并不会停下来。
3.如果source和destination有任何的重叠，复制的结果都是未定义的

模拟实现库函数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);
}

2.0 memmove

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

注：

1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。

模拟实现库函数memmove

void * memmove ( void * dst, const void * src, size_t count)
{
       void * ret = dst;
       if (dst <= src || (char *)dst >= ((char *)src + count)) {
               /*
                * Non-Overlapping Buffers
                * copy from lower addresses to higher addresses
                */
               while (count--)
               {
                       *(char *)dst = *(char *)src;
                       dst = (char *)dst + 1;
                       src = (char *)src + 1;
               }
       }
       else {
               /*
                * Overlapping Buffers
                * copy from higher addresses to lower addresses
                */
               dst = (char *)dst + count - 1;
               src = (char *)src + count - 1;
               while (count--) 
               {
                       *(char *)dst = *(char *)src;
                       dst = (char *)dst - 1;
                       src = (char *)src - 1;
               }
             }
       return(ret);
}

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

 

持续更新中，未完待续..

老铁们觉得对你有帮助还请点赞收藏转发评论，你的支持是对我最大的鼓励。