C语言的本质（22）——C标准库之字符串操作

编译器、浏览器、Office套件等程序的主要功能都是符号处理，符号处理功能在程序中占相当大的比例，无论多复杂的符号处理都是由各种基本的字符串操作组成的，下面介绍如何用C语言的库函数做字符串初始化、取长度、拷贝、连接、比较、搜索等基本操作。

1. 初始化字符串

头文件：string.h

函数原型：

void *memset(void *s, int c, size_t n);

memset函数将s所指向的某一块内存中的前n个 字节的内容全部设置为ch指定的ASCII值， 块的大小由第三个参数指定，这个函数通常为新申请的内存做初始化工作， 其返回值为指向s的指针。

例如定义char buf[10];，如果它是全局变量或静态变量，则自动初始化为0，如果它是函数的局部变量，则初值不确定，可以用memset(buf, 0, 10)清零，由malloc分配的内存初值也是不确定的，也可以用memset清零。

#include<string.h>
#include<stdio.h>

int main(void)
{
   buf[]="Hello world!\n";
   printf("Buffer before memset:%s\n",buf);
   memset(buffer,'*',strlen(buf));
   printf("Buffer after memset:%s\n",buf);
   return0;
}

2. 取字符串的长度

头文件：string.h

函数原型：

size_t strlen(const char *s);

strlen函数返回s所指的字符串的长度。该函数从s所指的第一个字符开始找'\0'字符，一旦找到就返回，返回的长度不包括'\0'字符在内。例如定义char buf[] = "hello";，则strlen(buf)的值是5，但要注意，如果定义charbuf[5] = "hello";，则调用strlen(buf)是危险的，会造成数组访问越界。

#include<string.h>
#include<stdio.h>
int main(void)
{
   char *s="Hello world!\n";
   printf("%s has %d chars",s,strlen(s));
   return0;
}

strlen与sizeof的区别

strlen(char*）函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0'，如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。

若char aa[10]; 则strlen(aa)结果是不定的

若char aa[10]={'\0'}; 则strlen(aa)则结果为0

若char aa[10]="jun"; 则strlen(aa)则结果为3

而sizeof（）返回的是变量声明后所占的内存数，不是实际长度，此外sizeof不是函数，仅仅是一个操作符，strlen是函数。

sizeof(aa) 返回10

int a[10]; sizeof(a) 返回40

1、sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned　int类型。

该类型保证能容纳实现所建立的最大对象的字节大小。

2、sizeof是操作符（关键字），strlen是函数。

3、sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。

sizeof还可以用函数做参数，比如：

short f();
printf("%d\n",sizeof(f()));

输出的结果是sizeof(short），即2。

4、数组做sizeof的参数不退化，传递给strlen就退化为指针了。

5、大部分编译程序 在编译的时候就把sizeof计算过了是类型或是变量的长度这就是sizeof(x）可以用来定义数组维数的原因

char str[20]="0123456789";

int a=strlen(str); //a=10;

int b=sizeof(str); //而b=20;

6、strlen的结果要在运行的时候才能计算出来，是用来计算字符串的长度，不是类型占内存的大小。

7、sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。

8、当适用了于一个结构类型时或变量，sizeof 返回实际的大小，

当适用一静态地空间数组， sizeof 归还全部数组的尺寸。

sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸

9、数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，如：

fun(char [8])
fun(char [])

都等价于 fun(char *)

3. 拷贝字符串

前面的博文介绍了strcpy和strncpy函数，拷贝以'\0'结尾的字符串，strncpy还带一个参数指定最多拷贝多少个字节，此外，strncpy并不保证缓冲区以'\0'结尾。现在介绍memcpy和memmove函数。

头文件：string.h

函数原型：

void *memcpy(void *dest, const void *src, size_t n);
void *memmove(void *dest, const void *src,size_t n);

返回值：dest指向哪，返回的指针就指向哪

memcpy函数从src所指的内存地址拷贝n个字节到dest所指的内存地址，和strncpy不同，memcpy并不是遇到'\0'就结束，而是一定会拷贝完n个字节。这里的命名规律是，以str开头的函数处理以'\0'结尾的字符串，而以mem开头的函数则不关心'\0'字符，或者说这些函数并不把参数当字符串看待，因此参数的指针类型是void *而非char *。

memmove也是从src所指的内存地址拷贝n个字节到dest所指的内存地址，虽然叫move但其实也是拷贝而非移动。但是和memcpy有一点不同，memcpy的两个参数src和dest所指的内存区间如果重叠则无法保证正确拷贝，而memmove却可以正确拷贝。假设定义了一个数组char buf[20] = "hello world\n";，如果想把其中的字符串往后移动一个字节（变成"hhello world\n"），调用memcpy(buf + 1,buf, 13)是无法保证正确拷贝的：

错误的memcpy调用

#include <stdio.h>
#include <string.h>

int main(void)
{
         charbuf[20] = "hello world\n";
         memcpy(buf+ 1, buf, 13);
         printf("%s",buf);
         return0;
}

运行结果：

hhelloo wold

4. 连接字符串

头文件：#include <string.h>

函数原型：

char *strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src,size_t n);

返回值：dest指向哪，返回的指针就指向哪strcat把src所指的字符串连接到dest所指的字符串后面，例如：

char d[10] = "foo";
char s[10] = "bar";
strcat(d, s);
printf("%s %s\n", d, s);

调用strcat函数后，缓冲区s的内容没变，缓冲区d中保存着字符串"foobar"，注意原来"foo"后面的'\0'被连接上来的字符串"bar"覆盖掉了，"bar"后面的'\0'仍保留。

strcat和strcpy有同样的问题，调用者必须确保dest缓冲区足够大，否则会导致缓冲区溢出错误。strncat函数通过参数n指定一个长度，就可以避免缓冲区溢出错误。注意这个参数n的含义和strncpy的参数n不同，它并不是缓冲区dest的长度，而是表示最多从src缓冲区中取n个字符（不包括结尾的'\0'）连接到dest后面。如果src中前n个字符没有出现'\0'，则取前n个字符再加一个'\0'连接到dest后面，所以strncat总是保证dest缓冲区以'\0'结尾，这一点又和strncpy不同，strncpy并不保证dest缓冲区以'\0'结尾。所以，提供给strncat函数的dest缓冲区的大小至少应该是strlen(dest)+n+1个字节，才能保证不溢出。

5. 比较字符串

头文件：#include <string.h>

函数原型：

int memcmp(const void *s1, const void *s2,size_t n);
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2,size_t n);

返回值：负值表示s1小于s2，0表示s1等于s2，正值表示s1大于s2memcmp从前到后逐个比较缓冲区s1和s2的前n个字节（不管里面有没有'\0'），如果s1和s2的前n个字节全都一样就返回0，如果遇到不一样的字节，s1的字节比s2小就返回负值，s1的字节比s2大就返回正值。

strcmp把s1和s2当字符串比较，在其中一个字符串中遇到'\0'时结束，按照上面的比较准则，"ABC"比"abc"小，"ABCD"比"ABC"大，"123A9"比"123B2"小。

strncmp的比较结束条件是：要么在其中一个字符串中遇到'\0'结束（类似于strcmp），要么比较完n个字符结束（类似于memcmp）。例如，strncmp("ABCD", "ABC", 3)的返回值是0，strncmp("ABCD","ABC", 4)的返回值是正值。

头文件：#include <strings.h>

函数原型：

int strcasecmp(const char *s1, const char*s2);
int strncasecmp(const char *s1, const char*s2, size_t n);

返回值：负值表示s1小于s2，0表示s1等于s2，正值表示s1大于s2这两个函数和strcmp/strncmp类似，但在比较过程中忽略大小写，大写字母A和小写字母a认为是相等的。这两个函数不属于C标准库，是POSIX标准中定义的。

6. 搜索字符串

头文件：#include <string.h>

函数原型：

char *strchr(const char *s, int c);
char *strrchr(const char *s, int c);

返回值：如果找到字符c，返回字符串s中指向字符c的指针，如果找不到就返回NULLstrchr在字符串s中从前到后查找字符c，找到字符c第一次出现的位置时就返回，返回值指向这个位置，如果找不到字符c就返回NULL。strrchr和strchr类似，但是从右向左找字符c，找到字符c第一次出现的位置就返回，函数名中间多了一个字母r可以理解为Right-to-left。

头文件：#include <string.h>

函数原型：

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

返回值：如果找到子串，返回值指向子串的开头，如果找不到就返回NULLstrstr在一个长字符串中从前到后找一个子串（Substring），找到子串第一次出现的位置就返回，返回值指向子串的开头，如果找不到就返回NULL。这两个参数名很形象，在干草堆haystack中找一根针needle，按中文的说法叫大海捞针，显然haystack是长字符串，needle是要找的子串。

7. 分割字符串

头文件：#include <string.h>

函数原型：

char *strtok(char *str, const char *delim);
char *strtok_r(char *str, const char*delim, char **saveptr);

返回值：返回指向下一个Token的指针，如果没有下一个Token了就返回NULL参数str是待分割的字符串，delim是分隔符，可以指定一个或多个分隔符，strtok遇到其中任何一个分隔符就会分割字符串。看下面的例子。

很多文件格式或协议格式中会规定一些分隔符或者叫界定符（Delimiter），例如/etc/passwd文件中保存着系统的帐号信息：

$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
......

每条记录占一行，也就是说记录之间的分隔符是换行符，每条记录又由若干个字段组成，这些字段包括用户名、密码、用户id、组id、个人信息、主目录、登录Shell，字段之间的分隔符是:号。解析这样的字符串需要根据分隔符把字符串分割成几段，C标准库提供的strtok函数可以很方便地完成分割字符串的操作。tok是Token的缩写，分割出来的每一段字符串称为一个Token。 

#include <stdio.h>
#include <string.h>

int main(void)
{
         charstr[] = "root:x::0:root:/root:/bin/bash:";
         char*token;

         token= strtok(str, ":");
         printf("%s\n",token);
         while( (token = strtok(NULL, ":")) != NULL)
                   printf("%s\n",token);

         return0;
}

$ ./a.out
root
x
0
root
/root
/bin/bash

从"root:x::0:root:/root:/bin/bash:"这个例子可以看出，如果在字符串开头或结尾出现分隔符会被忽略，如果字符串中连续出现两个分隔符就认为是一个分隔符，而不会认为两个分隔符中间有一个空字符串的Token。第一次调用时把字符串传给strtok，以后每次调用时第一个参数只要传NULL就可以了，strtok函数自己会记住上次处理到字符串的什么位置（显然这是通过strtok函数中的一个静态指针变量记住的）。