绿色记忆:使用C语言进行文本处理

使用C语言进行文本处理

/ in C

/ tags 文本处理

字符集问题

字符集（Charset）、代码页（Code page）、编码方式（Encoding）这三个术语常常描述一件事情——如何把字符存储为二进制形式（字节）。

严格的讲，字符集是字符的集合，编码方式则用于确定某个字符集中的字符如何编码（为字节），但是对于ASCII、GB 2312、Big5、GBK、GB 18030之类的遗留方案来说一种字符集只有一种编码方式，这导致某些时候术语字符集、编码方式被混用。而Unicode是严格区分字符集、编码的，Unicode字符集有 UTF-8、UTF-16、UTF-32等多种编码方式。

微软称当前Locale对应的字符集为ANSI，和ASCII没有关系，对于简体中文的Windows操作系统，ANSI通常就是GBK。

进行文本处理时，编码方式常常是令人头疼的问题。相比起其它语言，C/C++的编码方式问题比较复杂。造成这种复杂性的原因包括：

对于编码方式缺乏统一规范，依赖于编译器、操作系统
构建出的二进制可执行文件丢失字符串（char*）编码方式信息

使用C/C++处理字符串时，要注意四个层面的字符集（表格出现的字符集可以理解为编码方式）：

字符集

说明

源代码字符集

即作为编译输入的C/C++源代码文件使用的字符集。编译器必须能够正确的识别源文件的编码方式才能读取并处理之

对于GCC编译器，也称为输入字符集（Input charset）。源文件默认编码方式取决于编译器被调用时 LC_ALL 、 LC_* 、 LANG 等Locale相关环境变量，你也可以用编译器选项-finput-charset覆盖Locale

很多使用GCC或者其衍生工具条链（MinGW）的IDE，例如CLion、Eclipse，默认源代码使用UTF-8字符集
Visual Studio在简体中文的Windows下使用GBK字符集

编译器内部字符集

对于GCC编译器，也称为源字符集（Source charset）。GCC内部使用UTF-8编码方式

执行字符集

即Execution charset，二进制可执行文件中的字符串、字符的编码方式。这个编码影响二进制文件的尺寸，例如多字节字符串 char* str = "你好" 使用GBK时 strlen() 返回值4，使用UTF-8时返回6

对于GCC编译器，有两个选项控制执行字符集：
-fexec-charset，决定字符串（包括多字节字符）、字符的编码方式，默认UTF-8
-fwide-exec-charset，决定宽字符串、宽字符的编码方式，默认UTF-16或者UTF-32，一般和 wchar_t 宽度一致

控制台字符集

程序使用 printf() 等函数打印字符到控制台上，用户才能看到。控制台也需要知道自己打印的内容是什么编码方式，否则会显示为乱码

对于字符串， printf() 仅仅是简单的读取可执行文件中的字节流，并打印到输出流中，这要求你保证执行字符集和控制台字符集一致或兼容，否则乱码

对于宽字符串， wprintf() 需要读取宽字符串的编码（UTF-16/UTF-32），并将其转化为Locale指定的编码方式，然后打印到输出流。那么C程序如何得到Locale呢？

在所有C程序main函数执行前，它会调用 setlocale(LC_ALL,"C"); ，这个所谓的C是所有C程序使用的最小化的Locale。这个C仅支持少量字符，肯定会导致中文乱码。要解决此问题，可以在程序开始处手工调用 setlocale(LC_CTYPE, "") ，该调用后程序使用系统默认Locale来处理C字符串（CTYPE），其编码方式和控制台一般是一致的，因而避免了乱码

控制台使用的编码方式取决于软件或者OS，例如简体中文Windows操作系统中cmd.exe使用的代码页936类似于字符集GBK。你可以使用命令调整代码页：

rem 显示当前代码页（和字符集是类似的概念）

CHCP

rem 936是简体中文代码页，最初和GB2312一样，后来包含大部分的GBK字符

Active code page: 936

rem 切换为UTF-8代码页

CHCP 65001

Windows全局的Locale设置在控制面板中进行

Linux下可以设置Locale相关环境变量，来改变Terminal使用的字符集

C标准库

字符测试ctype.h

该头文件主要提供两类重要的函数：

字符类别测试
字符大小转换

该库提供的函数中都以int类型为参数，并返回一个int类型的值。实参类型应该隐式/显式转换为int类型

函数列表如下：

函数	说明
int isalnum(int c)	判断是否是字母或数字
int isalpha(int c)	判断是否是字母
int iscntrl(int c)	判断是否是控制字符
int isdigit(int c)	判断是否是数字
int isgraph(int c)	判断是否是可显示字符
int islower(int c)	判断是否是小写字母
int isupper(int c)	判断是否是大写字母
int isprint(int c)	判断是否是可显示字符
int ispunct(int c)	判断是否是标点字符
int isspace(int c)	判断是否是空白字符
int isxdigit(int c)	判断字符是否为16进制
int tolower(int c)	转换为小写字母
int toupper(int c)	转换为大写字母

字符串函数string.h

函数

说明

memchr()

在某一内存范围中查找一特定字符：

/**

* 扫描s所指内存的前n个字节，来寻找c出现的第一个位置

* c和s所指内存的字节，均被解释为unsigned char

* 返回指向匹配字节的指针，如果找不到返回NULL，rawmemchr()在找不到的情况下返回值未定义

void *memchr(const void *s, int c, size_t n); // 正向搜索

// 下面两个是GNU扩展

void *memrchr(const void *s, int c, size_t n); // 反向搜索

void *rawmemchr(const void *s, int c); // 正向搜索，不限制字节数

举例：

const char *mem = "0123456789";

char *p3 = (char *) memchr( mem, '3', strlen( mem ));

assert( p3 - mem == 3 );

memcmp()

比较内存内容：

/**

* 比较s1、s2两块内存区域的前n个字节

* 当s1小于、等于、大于s2时分别返回负数、0、正数

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

举例：

char *s1 = "abcdew";

char *s2 = "abcdez";

assert( memcmp( s1, s2, strlen( s1 ) - 1 ) == 0 );

assert( memcmp( s1, s2, strlen( s1 )) < 0 );

memcpy()

拷贝内存内容，两个内存区域必须不重叠：

/**

* 从src拷贝n个字节到dest

* 返回指向dest的指针

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

memmove()

移动内存内容，两个内存区域可以重叠：

/**

* 类似于memcpy，效果上相当于把src先拷贝到临时内存中，然后覆盖到dest

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

memset()

将一段内存空间填入某值，常用于内存清零：

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

strcat()

连接两字符串：

/**

* 将src附加到dest后面，覆盖dest结尾的\0，并在连接后再次添加一个\0

* 两个字符串不得重叠，并且dest必须由足够的空间来存放结果，如果dest空间不足则程序的行为无法预测

char *strcat( char *dest, const char *src );

/**

* 连接两字符串，与strcat类似，但是：

* 最多使用src的n个字节

* 如果src大于n字节，则它不需要以\0结束

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

举例：

char *dest = malloc( 100 );

strcat( dest, "Hello" );

strcat( dest, " World" );

assert( strcmp( dest, "Hello World" ) == 0 );

strchr()

在字符串中定位单个字符：

// 返回s中第一个c的指针，如果找不到返回NULL

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

// 返回s中最后一个c的指针

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

// 与strchr()类似，但是在找不到的时候，返回s结尾的\n的指针而不是NULL

char *strchrnul(const char *s, int c);

strcmp()

比较字符串：

//比较s1、s2，在s1小于、等于、大于s2时分别返回负数、0、正数

int strcmp( const char *s1, const char *s2 );

//比较s1、s2的前n个字节

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

strcoll()

使用当前Locale比较两个字符串，结果受 LC_COLLATE 影响：

1	int strcoll(const char s1, const char s2);

strcpy()

拷贝字符串：

/**

* 拷贝src，包含结尾的\0，到dest。dest必须足够大，两个字符串不得重叠

char *strcpy( char *dest, const char *src );

// 类似，但是最多拷贝n字节，注意，该函数可能导致结尾的\0丢失

char *strncpy( char *dest, const char *src, size_t n );

strspn()

依据一系列字节来搜索字符串：

/**

* 搜索s，直到出现不在accept中的字节

* 返回从头开始，一直处于accept中的字符的个数

size_t strspn( const char *s, const char *accept );

/**

* 搜索s，知道出现在reject中的字节

* 返回从头开始，第一个在reject中的字节之前的字节总数

size_t strcspn( const char *s, const char *reject );

举例：

1	assert( strspn( "54213zyx", "1234567890" ) == 5 );

strerror()

返回错误原因的描述字符串，举例：

1	printf( strerror( 2 ));//No such file or directory

strlen()

计算字符串长度，得到的是字节数量：

1 2	assert( strlen( "nh" ) == 2 ); assert( strlen( "你好" ) == 6 );

strpbrk()

查找字符串中第一个出现的指定字节：

/**

* 搜索s，直到出现accept中的任何一个字节

* 返回第一个accept中的字节，如果找不到返回NULL

char *strpbrk( const char *s, const char *accept );

strstr()

在一字符串中查找指定的子串：

/**

* 返回haystack中第一次出现needle的、needle的起始字节的指针，结尾的\0不参与比较

* 如果子串找不到返回NULL

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

// GNU扩展，与上面类似，但是不区分大小写

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

strtok()

将字符串分割为0个或多个非空字符串：

/**

* 第一次调用时，传递待分割的字符串到str，后续分割同一字符串的操作，必须传递NULL给str

* delim是一系列作为分隔符的字节，后续调用可以改变delim

* 每次调用的返回值是指向分割得到的子串的指针，没有更多的记号时返回NULL

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

/**

* strtok()的可重入版本

* saveptr是供函数内部使用的一个指针，保存分隔上下文

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

举例：

char str[] = "123:456,789....0";

char *token;

char *ctx = str;

while ( token = strtok_r( ctx, ":,.", &ctx )) {

printf( "%s|", token );

}

//打印123|456|789|0| 可以看到....中间的不作为子串

注意，该函数修改了str的内容：它把分隔字符替换为\0

strxfrm()

拷贝字符串：

/**

* 拷贝src的n个字节到数组dest中，返回拷贝后的字符串的长度

* 如果返回值大于等于n则dest数组的内容是不确定的

size_t strxfrm( char *dest, const char *src, size_t n );

举例：

char *source = "1234567890";

char des[100];

size_t len = strxfrm( des, source, 50 );

assert( len == 10 && strcmp( des, source ) == 0 );

memset( des, 0, 100 );

len = strxfrm( des, source, 5 );

assert( len == 10 && strcmp( des, "12345" ) == 0 );

宽字符串函数wchar.h

所谓宽字符，是指使用多个字节表示的字符。宽字符类型具有固定宽度，但是宽度取决于平台（编译器），这意味着使用宽字符会导致可移植性问题。宽字符在Linux系统中使用的不多。

在2011年的C和C++标准中固定宽度的字符类型 char16_t 、 char32_t 被引入，用来表示无歧义的16位、32位的Unicode转换格式（UTF）。

函数

说明

btowc()

把单个字节转换为宽字符：

/**

* 执行单字节字符到宽字符的转换

* @param c 单字节字符

* @return 转换c所代表的字符的宽字符表示

* 如果c为EOF或者不是有效单字节字符，返回WEOF

wint_t btowc( int c );

避免使用该函数，因为其无法处理带有状态的编码方式。使用 mbtowc() 或者线程安全的 mbrtowc() 代替之：

/**

* 从多字节序列s中抽取出一个宽字符，该函数最多检查s的n个字节，并把转换后得到的宽

* 字符存放在*pwc中，返回从s中消费掉的字节数。该函数在内部维护一个偏移状态（Shift state）导致其线程不安全

* 该函数需要知道s的编码方式，这是由当前Locale的LC_CTYPE目录决定的，因此调用该函

* 数前你可能需要调用setlocale来设置多字节使用的编码方式

int mbtowc( wchar_t *pwc, const char *s, size_t n );

举例：

setlocale( LC_ALL, "" );

char *str = "你好，世界";

wchar_t wc = 0;

// MB_CUR_MAX 当前Locale下多字节字符占据的最大字节数

int len = mblen( str, MB_CUR_MAX);

str += mbtowc( &wc, str, len * strlen( str ));

wprintf( L"%lc \n", wc ); //你

str += mbtowc( &wc, str, len * strlen( str ));

wprintf( L"%lc \n", wc ); //好

wctob()

执行宽字符到单字节字符的转换，避免使用该函数，使用 wctomb() 代替之：

/**

* 转换宽字符wc为多字节序列，存放到s中，程序员必须保证s至少由MB_CUR_MAX字节

* 如果s非NULL，返回写入到s中的字节数

* 如果s为NULL，该函数重置内部的Shift state为初始状态，并返回

* 零（如果多字节编码方式是无状态的）或非零

int wctomb(char *s, wchar_t wc);

举例：

setlocale( LC_ALL, "" );

char buf[64];

char *str = buf;

str += wctomb( str, L'你' );

str += wctomb( str, L'好' );

printf( "%s", buf ); //你好

wprintf()

//下面三个函数和对应单字节字符的版本功能类似

int fwprintf( FILE *stream, const wchar_t *format, ... );

int wprintf( const wchar_t *format, ... );

int swprintf( wchar_t *s, size_t n, const wchar_t *format, ... );

vwprintf()

//下面三个函数与上面类似，但是使用列表而不是变长参数

int vwprintf( const wchar_t *format, va_list arg );

int vfwprintf( FILE *stream, const wchar_t *format, va_list arg );

int vswprintf( wchar_t *s, size_t n, const wchar_t *format, va_list arg );

wscanf()

//下面三个函数和对应单字节字符的版本功能类似

int fwscanf( FILE *stream, const wchar_t *format, ... );

int wscanf( const wchar_t *format, ... );

int swscanf( const wchar_t *s, const wchar_t *format, ... );

iswalnum()

1 2	//测试在当前Locale下，字符是否字母或者数字 int iswalnum( wint_t wc );

iswalpha()

1 2	//测试在当前Locale下，字符是否字母 int iswalpha( wint_t wc );

iswxdigit()

1 2	//测试在当前Locale下，字符是否属于十六进制字符 int iswxdigit( wint_t wc );

iswcntrl()

1 2	//测试在当前Locale下，字符是否为控制字符 int iswcntrl( wint_t wc );

iswgraph()

1 2	//测试在当前Locale下，字符是否为可见 int iswgraph( wint_t wc );

iswprint()

1 2	//测试在当前Locale下，字符是否为可打印字符 int iswprint( wint_t wc );

iswspace()

1 2	//测试在当前Locale下，字符是否为空白字符 int iswspace( wint_t wc );

iswupper()
iswlower()

//是否大小写判断

int iswupper( wint_t wc );

int iswlower( wint_t wc );

towupper()
towlower()

//转换为大小写

wint_t towupper( wint_t wc );

wint_t towlower( wint_t wc );

fgetwc()

//从文件流中读取下一个宽字符

wint_t fgetwc( FILE *stream );

//与上面类似，但是作为宏实现

wint_t getwc(FILE *stream);

getwchar()

1 2	//从标准输入读取一个宽字符 wint_t getwchar(void);

fputwc()

//写入一个宽字符到文件流

wint_t fputwc( wchar_t wc, FILE *stream );

//与上面类似，但是作为宏实现

wint_t putwc(wchar_t wc, FILE *stream);

putwchar()

1 2	//写入一个宽字符到标准输出 wint_t putwchar( wchar_t wc );

fgetws()

1 2	//从文件流中读取宽字符串 wchar_t fgetws( wchar_t ws, int n, FILE *stream );

fputws()

1 2	//写入宽字符串到文件流 int fputws( const wchar_t ws, FILE stream );

fwide()

/**

* 修改流为面向字节/面向宽字符

* @param stream 目标流

* @param mode 1尝试修改为面向宽字符；-1尝试修改为面向字节；0不变

int fwide( FILE *stream, int mode );

wcscat()

1 2	//连接两个宽字符串 wchar_t wcscat( wchar_t ws1, const wchar_t *ws2 );

wcsncat()

1 2	//连接ws2的最多n个字符到ws1，不包括\0字符 wchar_t wcsncat( wchar_t ws1, const wchar_t *ws2, size_t n );

wcschr()

/**

* 搜索字符串，返回字符在串中第一次出现

* @param ws 字符串

* @param wc 搜索的字符

* @return 第一次出现的字符的指针，或者NULL

wchar_t *wcschr( const wchar_t *ws, wchar_t wc );

//返回字符在串中的最后一次出现

wchar_t *wcsrchr( const wchar_t *ws, wchar_t wc );

wcspbrk()

1 2	//得到第一个出现在ws1中的任何ws2中的字符 wchar_t wcspbrk( const wchar_t ws1, const wchar_t *ws2 );

wcscmp()

/**

* 比较两个宽字符串，如果ws1大于ws2，返回正数；等于则返回0；小于返回负数

* 非零返回值说明了两者的差异

int wcscmp( const wchar_t *ws1, const wchar_t *ws2 );

wcscpy()

//将字符串ws2拷贝到ws1，如果两个串存在字符重叠，则行为未定义

wchar_t *wcscpy( wchar_t *ws1, const wchar_t *ws2 );

//将字符串ws2的最多n个字符拷贝到ws1，如果出现字符重叠，则行为未定义

wchar_t *wcsncpy( wchar_t *ws1, const wchar_t *ws2, size_t n );

wcsftime()

1 2	//将日期时间转换为宽字符串 size_t wcsftime( wchar_t wcs, size_t maxsize, const wchar_t format, const struct tm *timptr );

wcslen()

1 2	//得到宽字符串的长度，不包括结尾的0字符，结果是字符的个数，而不是字节数 size_t wcslen( const wchar_t *ws );

wcsstr()

//搜索子串的第一次出现，如果找不到返回NULL，如果ws2是空串，那么直接返回ws1

wchar_t *wcsstr( const wchar_t *ws1, const wchar_t *ws2 );

//类似上面的宏版本

wchar_t *wcswcs( const wchar_t *ws1, const wchar_t *ws2 );

wcstok()

1 2	//根据分隔符，分隔宽字符串 wchar_t wcstok( wchar_t ws1, const wchar_t ws2, wchar_t *ptr );

wmemchr()

1 2	//在长度为n字符的ws中寻找第一次出现的wc wchar_t wmemchr( const wchar_t ws, wchar_t wc, size_t n );

wmemcmp()

1 2	//比较两个字符串的前n个字符 int wmemcmp( const wchar_t ws1, const wchar_t ws2, size_t n );

wmemcpy()

1 2	//把ws2的前n个字符拷贝到ws1，返回ws1 wchar_t wmemcpy( wchar_t ws1, const wchar_t *ws2, size_t n );

wmemset()

1 2	//设置ws的前n个字符为wc wchar_t wmemset( wchar_t ws, wchar_t wc, size_t n );

格式化输出

stdio.h中定义了一系列用于格式化输出的函数，包括：

#include <stdio.h>

/**

* 将format指定的格式使用后续参数填充后，打印到标准输出

int printf( const char *format, ... );

/**

* 将format指定的格式使用后续参数填充后，打印到流stream

int fprintf( FILE *stream, const char *format, ... );

/**

* 将format指定的格式使用后续参数填充后，打印到str指定的缓冲区

int sprintf( char *str, const char *format, ... );

//类似上面，但是最多打印size字节

int snprintf( char *str, size_t size, const char *format, ... );

#include <stdarg.h>

// 类似上面，但是使用使用va_list而不是变长参数列表

int vprintf( const char *format, va_list ap );

int vfprintf( FILE *stream, const char *format, va_list ap );

int vsprintf( char *str, const char *format, va_list ap );

int vsnprintf( char *str, size_t size, const char *format, va_list ap );

此外，对应的还有格式化输入的函数：

#include <stdio.h>

int scanf(const char *format, ...);

int fscanf(FILE *stream, const char *format, ...);

int sscanf(const char *str, const char *format, ...);

#include <stdarg.h>

int vscanf(const char *format, va_list ap);

int vsscanf(const char *str, const char *format, va_list ap);

int vfscanf(FILE *stream, const char *format, va_list ap);

这些函数的宽字符版本在wchar.h中声明。

上述所有函数中的format遵守一致的规范。format由普通字符和若干转换规则（conversion specifications）组成。后者导致列表中下一个参数被转换并打印。转换规则的语法为：

1	%[#0- +'][宽度][.精度][长度限定符][转换符]

其中：

标记	说明
%	表示转换规则的开始
# 0 - + '	这些字符紧随着%，可以出现一个或者多个： # 表示输出为备选格式：对于o转换符需要输出为0开头，对于x或X需要输出为0x/0X开头。对于a, A, e, E, f, F, g会总是输出小数点 0 基于0来补白，对于d, i, o, u, x, X, a, A, e, E, f, F, g,G转换后的值在左边使用0而不是空格填充，如果指定-或者精度该标记被忽略 - 进行左对齐，默认是右侧对齐空格对于有符号的转换符，在正数前添加一个空格 ' 对于数字转换符，使用千分位分组
宽度	表示字段的最小宽度，如果目标参数长度不够，会自动补白
.精度	精度：字符串的最大的字符数；浮点数小数部分的位数；整数的最小数字个数
长度限定符	hh 如果后续整数转换符则输出signed/unsigned char，后续n转换符则输出signed char* h 如果后续整数转换符则输出signed/unsigned short，后续n转换符则输出signed short* l 如果后续整数转换符则输出signed/unsigned long，后续n转换符则输出signed long* 后续c转换符则输出wint_t，后续s则输出wchar_t* ll 如果后续整数转换符则输出signed/unsigned long long，后续n转换符则输出signed long long* L 如果后续a, A, e, E, f, F, g或G则输出long double格式

可用的转换符如下表：

转换符	说明
d,i	int，格式化为十进制整数可以附加前缀l，用于格式化long类型，例如li、ld
o	int，格式化为八进制整数（无符号），默认前缀0省略
x,X	int，格式化为十六进制整数（无符号），默认前缀0x省略。X表示字母大写打印
u	unsigned int，打印为无符号整数可以附加前缀l，用于格式化long类型，例如lu
c	int，打印单个字符
s	char*，打印字符串，直到遇到\0，或者到达精度限制
f	double，打印为：[-]m.dddddd，小数部分默认6
e,E	double，打印为：[-]m.dddddde+/-xx或者[-]m.ddddddE+/-xx，其中d为精度
g,G	double，如果指数小于-4或者大于等于精度，使用%e、%E输出；否则使用%f输出，尾部的0和小数点不打印
p	void*，打印指针
%	原样打印字符%

第三方库

C标准库的功能非常有限，并且比较难用或存在性能问题，很多情况下需要使用第三方库。

SDS

SDS是一个简单的动态字符串库，原本是Redis内部的组件。它在内部维护一个基于堆的缓冲区，避免受到C标准库的限制，SDS兼容普通的C字符串函数。

典型的C动态字符串库是基于下面的结构实现的：

struct DynamicString {

char *buf;

size_t len;

//其它字段

};

SDS没有遵循这一模式，它由头部+二进制安全的C风格字符串+NULL字符构成。SDS的结构导致它具有一些缺点和优点。

SDS的缺点

SDS的很多函数会可能返回一个新字符串，而不是修改原有字符串，所以很多SDS API必须这样使用：

1	s = sdscat(s,"more data");

如果忘记把返回值赋值给原先的变量可能导致BUG。

进一步讲，如果你在多个地方引用同一个SDS，调用上述函数后必须赋值所有引用。

SDS的优势

你可以直接对SDS变量使用C标准库函数，例如：

printf("%s\n", sds);

//其它库一般是这样：

printf("%s\n", str->buf);

//或者这样：

printf("%s\n", getStringPointer(str));

索引方式访问单个字符也是支持的：

1	printf("%c %c\n", sds[0], sds[1]);

SDS的API

函数

说明

sdsnew()
sdsnewlen()
sdsempty()
sdsdup()

这些函数用于创建新的动态字符串：

/**

* 创建一个动态字符串，初始值从init的前initlen中取得

sds sdsnewlen( const void *init, size_t initlen );

/**

* 创建一个动态字符串，初始值由init指定，init必须由\0结束

sds sdsnew( const char *init );

/**

* 创建一个空白的动态字符串

sds sdsempty( void );

/**

* 从s复制一个新的动态字符串

sds sdsdup( const sds s );

sdslen()

获得动态字符串的长度： size_t sdslen(const sds s);
类似于标准库的strlen()函数，但是：

该函数消耗时间是固定的，原因是SDS的长度存放在头部字段中
与其它SDS函数一样，该函数也是二进制安全的。其返回的长度是字符串的真实长度，即是中间包含\0字符：

C

1

sdslen(sdsnewlen("A\0\0B",4)) == 4

sdsfree()

销毁动态字符串，即使空串也必须销毁，否则内存泄漏：

1	void sdsfree(sds s);

sdscat()
sdscatlen()
sdscatsds()

连接字符串：

/**

* 将缓冲区t的前len个字节连接到动态字符串中，返回（可能是）新的动态字符串

sds sdscatlen( sds s, const void *t, size_t len );

/**

* 将字符串连接到s，返回（可能是）新的动态字符串

sds sdscat( sds s, const char *t );

/**

* 将动态字符串t连接到s，返回（可能是）新的动态字符串

sds sdscatsds(sds s, const sds t);

举例：

sds hello = sdsnew( "Hello " );

sds world = sdsnew( "World" );

hello = sdscatsds( hello, world );

sdsfree( world );

sdsgrowzero()

确保动态字符串的长度：

1 2	// 如果s的长度大于等于len什么都不做，否则扩充到len长并使用0填充 sds sdsgrowzero(sds s, size_t len);

sdscatprintf()

格式化字符串并连接到动态字符串：

/**

* 根据fmt和后续参数进行字符串格式化，然后连接到动态字符串s中

sds sdscatprintf(sds s, const char *fmt, ...);

举例： sdscatprintf(sdsempty(), "%s %s", "Hello", "Alex");

sdsfromlonglong()

从数字创建字符串：

1	sds sdsfromlonglong(long long value);

举例：

1 2	sds num = sdsfromlonglong( 9460500000000 ); assert( 0 == strcmp( "9460500000000", num ));

sdstrim()

修剪字符串：

/**

* 修剪动态字符串s，清除左侧或者右侧的、存在于cset中的字符

void sdstrim( sds s, const char *cset );

举例：

sds str = sdsnew( "\n\nHello World " );

sdstrim( str, "\n " );

assert( strcmp( "Hello World", str ) == 0 );

sdsrange()

修剪为子串：

/**

* 修改动态字符串s，保留从start到end的部分，end包含在内

void sdsrange( sds s, int start, int end );

sdscpy()
sdscpylen()

strcpy() 是C标准库中最危险和恶名的操作之一。SDS提供的相应的操作则可用于性能关键的领域：

/**

* 拷贝t到动态字符串s中

sds sdscpy( sds s, const char *t );

/**

* 拷贝t的前len个字节到动态字符串s中

sds sdscpylen(sds s, const char *t, size_t len);

scscatrepr()

连接字符串，并将其中的不可打印字符使用转义字符的形式显示出来：

sds sdscatrepr(sds s, const char *p, size_t len);

//示例：

sds s = sdsempty();

char q[10];

q[0] = 'A';q[1] = 1;q[2] = 20;q[4] = '\t';q[3] = '\n';

s = sdscatrepr(s,q,10);

printf( s ); //输出："A\x01\x14\n\t\x7f\x00\x00\x00\x00"

sdssplitlen()
sdsfreesplitres()

标记化（Tokenization）：将一个大字符串分隔（split）为多个小字符串：

/**

* s的前len个字节用来被分割，sep的前len字节用作分隔符，count用于返回子串的数量

sds *sdssplitlen( const char *s, int len, const char *sep, int seplen, int *count );

// 销毁子串资源

void sdsfreesplitres( sds *tokens, int count );

举例：

char *str = "1986,.1989.,2014";

int count;

sds *substrs = sdssplitlen( str, strlen( str ), ",.", 2, &count );

for ( int i = 0; i < count; ++i ) {

sds substr = *( substrs + i );

printf( "%s\n", substr );

//打印：

//1986

//1989.,2014

}

sdsfreesplitres( substrs, count );

sdsjoin()
sdsjoinsds()

使用分隔符连接一组字符串：

/**

* 使用sep中的前seplen个字符作为分隔符，连接长度为argc的字符串数组

sds sdsjoin( char **argv, int argc, char *sep, size_t seplen );

//类似上面

sds sdsjoinsds( sds *argv, int argc, const char *sep, size_t seplen );

举例：

1 2	char *strs[3] = { "foo", "bar", "zap" }; printf( sdsjoin( strs, 3, "-" )); //打印：foo-bar-zap

sdsRemoveFreeSpace()

收缩可变字符串，移除空闲的空间，在内存受限环境下可以使用：

1	sds sdsRemoveFreeSpace(sds s);

sdsAllocSize()

获得一个可变字符串实际分配的空间：

1	size_t sdsAllocSize(sds s);

sdsupdatelen()

改变逻辑长度，反映出C字符串的长度：

void sdsupdatelen( sds s );

// 举例

sds s = sdsnew( "foobar" );

s[2] = '\0';

assert( sdslen( s ) == 6 );

sdsupdatelen(s);

// 更新逻辑长度后，sds的长度与C字符串长度一致

assert( sdslen( s ) == 2 );

上面这些函数，但凡返回sds的，在内存溢出的情况下一律会返回空指针。

SDS的技术细节

SDS头部由下面的数据结构表示：

struct sdshdr {

int len; // 保存动态字符串的长度

int free; // 保存缓冲区空闲字节数，这些空闲字节可以容纳更多的字符

char buf[]; // 未声明长度的数组，因此它实际上指向free后面的那个字节，这很重要

};

结构中的buf字段是一个flexible array member，它是C99引入的特性——位于结构体最后的无长度的数组。该数组的指针指向紧跟着结构体的内存，下面的示例代码可以验证这一点：

typedef struct {

int len;

char buf[];

} head;

int main() {

void *mem = malloc( 1024 );

head *h = mem;

char *str = mem + sizeof( head );

str[0] = 'A'; str[1] = 'B';

printf( h->buf ); // 打印AB

return 0;

}

要创建一个SDS，只需要在堆上分配不小于sdshdr长度+字符串长度的内存即可。但是为了避免每次操控都导致新的内存分配，SDS总是预分配一些额外的内存。SDS的预分配算法是：当每次进行内存分配时，实际分配的内存是最小需求量的2倍。内存分配的最大量由宏 SDS_MAX_PREALLOC 控制。

共享SDS

如果你需要在多个数据结构中共享SDS动态字符串，应当将SDS封装在具有引用计数的结构体中，避免编程错误导致的内存泄漏：

struct ds {

int refcount;

sds str;

}

你应当提供增加、减少引用计数的函数：

每当其它数据结构引用ds或者将ds赋值给变量时，都应当增加引用计数
每当引用移除时，减少计数，计数为0时，自动销毁SDS字符串

零拷贝（Zero copy）连接

在Redis中，为了增强性能使用了SDS提供的一些低级API。使用 sdsIncrLen() 和 sdsMakeRoomFor() 可以将来自内核的字节直接连接到SDS尾部，而不需要中介的缓冲区：

oldlen = sdslen(s);

s = sdsMakeRoomFor(s, BUFFER_SIZE);

nread = read(fd, s+oldlen, BUFFER_SIZE); // 系统调用

sdsIncrLen(s, nread);

← Howard Blake.Walking In The Air

MinGW知识集锦 →

使用C语言进行文本处理

使用C语言进行文本处理

Leave a Reply Cancel reply

ABOUT ME

ABOUT GMEM

GMEM HISTORY

MIRROR INFO

Meta

Recent Posts

TOPLINKS

Recent Comments