【C语言进阶】字符函数和字符串函数

前言
在文章之前我们要知道C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中 或者字符数组中。 字符串常量适用于那些对它不做修改的字符串函数.

介绍常用字符串函数

1.strlen(字符串长度)
2.strcpy
3.strcat
4.strcmp
5.strncpy
6.strncat
7.strncmp
8.strstr(字符串查找)
9.strtok
10.strerror(错误信息报告)
内存操作函数
11.memcpy
12.memmove
13.memset
14.memcmp

strlen

my_strlen ( const char * str );
字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )
strlen和sizeof不同的就是‘\0’
接下来我们要做的就是实现函数（这里要记住sizeof和strlen的不同之前文章提到过）

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

strcpy

介绍：cpy也就是拷贝也就是将source拷贝进destination中
1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
4.目标空间必须可变。 学会模拟实现
函数的模拟实现

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

strcat

注释：1.源字符串必须以 ‘\0’ 结束。
2.目标空间必须有足够的大，能容纳下源字符串的内容。
3.目标空间必须可修改
模拟实现

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

这里我要提一下assert为什么要有个这么语句其实是断言的意思就是在之前判断这个指针是否为空如果我们传参进去指的是空指针我们就没有往下进行的必要。

strcmp

规定：
1.第一个字符串大于第二个字符串，则返回大于0的数字
2.第一个字符串等于第二个字符串，则返回0
3.第一个字符串小于第二个字符串，则返回小于0的数字
模拟实现

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

长度限制的函数

strncpy
strncat
strncmp
这三个函数和之前差不多大家能发现有什么区别吗？
对 都有一个N为什么都加了个N这就是对长度的限制
举例：
char * strcat ( char * destination, const char * source );

char * strncat ( char * destination, const char * source, size_t num )
多了一个对size的限制所以模拟函数的时候也就需要加个对长度的限制就行。

strstr

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

strstr就相当于孩子去找父母
看输入的字符串是否是前一个字符串的子串也
举个例子 一个集合A（1，3，4，5）
如果B（1，4）进去找那么B就是A的子集
模拟函数

char *my_strstr(const char* str1, const char* str2 ) 
{
       
    assert(str1);  
    assert(str2);    
    char *cp = (char*)str1;  
    char *substr = (char *)str2;  
    char *s1 = NULL;    
    if(*str2 == '\0')   return NULL;     
           while(*cp) 
           {
        
              s1 = cp;   
              substr = str2;   
              while(*s1 && *substr && (*s1 == *substr))   
              {
        
               s1++;    
               substr++; 
              }
              if(*substr == '\0')    
               return cp;   
                cp++; 
         }
 }

运用代码

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

strtok

char * strtok ( char * str, const char * sep );
1.sep参数是个字符串，定义了用作分隔符的字符集合
2.第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
3. strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改 变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
4. strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
5. strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
6. 如果字符串中不存在更多的标记，则返回 NULL 指针
运用代码

#define _CRT_SECURE_NO_WARNINGS 1
#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;
}

运行结果

strerror

返回错误码 所对应的错误信息运用就得包含其头文件

#include  
#include 
#include 
//必须包含的头文件

字符分类函数介绍

memcpy

规则：
1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。 2.这个函数在遇到 ‘\0’ 的时候并不会停下来。
3.如果source和destination有任何的重叠，复制的结果都是未定义的
这个函数和strcpy不同地方就是一个是字符串拷贝一个是内存拷贝其余的都相同也可以限制长度

memmove

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

void* my_memmove(void* dst, const void* src, int size)
{
     
	assert(src);
	assert(dst);

	char* str_dst = (char*)dst;
	const char* str_src = (const char*)src;
	// 1、后重叠，或者是不重叠右边的拷贝，倒着拷贝
	// 2、前重叠，或者是不重叠左边的拷贝，正着拷贝
	if(str_src < str_dst)
	{
     
		for (int end = size - 1; end >= 0; --end)
		{
     
			//*(str_dst+end) = *(str_src + end);
			str_dst[end] = str_src[end];
		}
	}
	else
	{
     
		for (int start = 0; start < size; ++start)
		{
     
			str_dst[start] = str_src[start];
		}
	}

	return dst;
}

memcmp

定义：int memcmp ( const void * ptr1, const void * ptr2, size_t num );
规则：比较从ptr1和ptr2指针开始的num个字节 返回值如下：
与strcmp不同的就是memcmp会比较‘\0’后边的值而strcmp不会