简单的字符串函数讲解

本章重点

求字符串长度

strlen

size_t strlen ( const char * str );

该函数是用来表示字符串的长度的
该函数需要注意以下事项：

• 字符串以\0作为结束标志，strlen函数返回的是在字符串中“\0”前面出现的字符个数
• 参数指向的字符串必须要是以\0结束
• 注意函数的返回值为size_t，是无符号的。
• 学会strlen函数的模拟实现

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

strcpy

• 源字符串必须以\0结束
• 会将字符串中的\0拷贝到目标空间
• 目标空间必须足够大，以确保可以存放字符串
• 目标空间必须可变
• 学会模拟实现 模拟实现是通过自己构造函数实现

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

strcat

• 源字符串必须以\0结束
• 目标空间必须足够大，以确保可以存放字符串
• 目标空间必须可变
• 学会模拟实现 模拟实现是通过自己构造函数实现

char *my_strcpy(char *dest,char * sre)
{
char *ret=dest;
assert(*dest!=NULL&&*sre!=NULL);
whiie(*dest)
{
dest++;
}
while(*dest++=*sre++)
{
;
}
return ret;
}

strcmp

• 第一个字符串大于第二个字符串，则返回大于0的数字
• 第一个字符串等于第二个字符串，则返回0
• 第一个字符串小于第二个字符串，则返回小于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

strbcmp

这三个字符串函数分别对应上面的三个字符串函数，实现也类似于给出的函数，可以参考上面给的三段代码块。

字符串查找

strstr

用途寻找一个字符串中的目标字符串；

#include <stdio.h>
#include <string.h>
int main() 
{ 
	char str[] = "This is a simple string"; 
	char* pch;
	pch = strstr(str, "simple"); 
	strncpy(pch, "simple", 6);
	puts(str); 
	return 0;
}

strtok

该函数的作用是将字符串分块，例如
192.168.135.23.00
分割成192
168
135
23
00

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

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

作用是；
通过标准错误的标号，获得错误的描述字符串 ，将单纯的错误标号转为字符串描述，方便用户查找错误

`/* strerror example : error list */
#include <stdio.h>
#include <string.h>
#include <errno.h>//必须包含的头文件
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;
    }Edit & Run`## 字符操作

内存操作函数

memcpy

作用是abcdef把ab复制到ef上

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

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

用自建函数实现

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

memmove

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

用代码实现；

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