字符函数和字符串函数

常见的字符和字符串的库函数：

求字符串长度

strlen

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

strcpy、strcat、strcmp

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

strncpy、strncat、strncmp

字符串查找

Strstr、strtok

错误信息报告

strerror

字符操作

内存操作函数：memcpy、memmove、memset、memcmp

前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

字符串常量 适用于那些对它不做修改的字符串函数.

1. 函数介绍

1.1size_t strlen ( const char * str );

• 字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。

• size_t strlen ( const char * str );

• 参数指向的字符串必须要以 '\0' 结束。

• 注意函数的返回值为size_t，是无符号的（ 易错 ）

/* strlen example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char szInput[256];
  printf ("Enter a sentence: ");
  gets (szInput);
  printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
  return 0;
}

模拟实现：

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

1.2 strcpy

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

• Copies the C string pointed by source into the array pointed bydestination, including the

• terminating null character (and stopping at that point).

• 源字符串必须以 '\0' 结束。

• 会将源字符串中的 '\0' 拷贝到目标空间。

• 目标空间必须足够大，以确保能存放源字符串。目标空间必须可变。

模拟实现：

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

1.3 strcat

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

Appends a copy of the source string to thedestination string. The terminating null character

in destination is overwritten by the firstcharacter of source, and a null-character is included

at the end of the new string formed by theconcatenation of both in destination.

• 源字符串必须以 '\0' 结束。

• 目标空间必须有足够的大，能容纳下源字符串的内容。

• 目标空间必须可修改。

/* strcat example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[80];
  strcpy (str,"these ");
  strcat (str,"strings ");
  strcat (str,"are ");
  strcat (str,"concatenated.");
  puts (str);
  return 0;
}
//Output:
these strings are concatenated.

模拟实现：

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

This function starts comparing the first characterof each string. If they are equal to each

other, it continues with the followingpairs until the characters differ or until a terminating

null-character is reached.

标准规定：

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

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

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

1.5 strncpy

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

• Copies the first num characters of source to destination. If the endof the source C string

(which is signaled by a null-character) is found before numcharacters have been copied,

destination is padded with zeros until a total of numcharacters have been written to it.

• 拷贝num个字符从源字符串到目标空间。

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

1.6 strncat

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

• Appends the first num characters of source to destination, plus aterminating null-character.

• If the length of the C string in source is less than num, only thecontent up to the terminating null-character is copied.

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

1.7strncmp

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

比较到出现另个字符不一样或者一个字符串结束或者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.8 strstr

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

Returns a pointer to the first occurrenceof str2 in str1, or a null pointer if str2 is not part of str1.

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

模拟实现：

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.9 strtok

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

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

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

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

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

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

如果字符串中不存在更多的标记，则返回 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.10 memcpy

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

函数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 * 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);
}

1.11 memmove

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

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

模拟实现：

#include<stdio.h>
#include<string.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    if(dest <= src)
    while (num--)
    {
    *(char*)dest = *(char*)src;
    dest = (char*)dest + 1;
    src = (char*)src + 1;
    }
    else
    {
        while (num--)
        {
        *((char*)dest + num) = *((char*)src + num);
        }
    }
return ret;
}
int main()

{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };   
    my_memmove(arr, arr + 1, 20);   
return 0;

}

1.12 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' isgreater than '%s'.\n",buffer1,buffer2);
     else if (n<0) printf ("'%s'is less than '%s'.\n",buffer1,buffer2);
     else printf ("'%s' is the sameas '%s'.\n",buffer1,buffer2);
 return 0;
}