#include <string.hpp>

类 acl::string 继承关系图:

acl::string 的协作图:

Public 成员函数
	string (size_t n, bool bin)

	string (size_t n)

	string (void)

	string (const string &s)

	string (const char *s)

	string (const void *s, size_t n)

	string (int fd, size_t max, size_t n)

virtual	~string (void)

string &	set_bin (bool bin)

string &	set_max (int max)

bool	get_bin () const

int	get_max (void) const

char	operator[] (size_t n) const

char	operator[] (int n) const

char &	operator[] (size_t n)

char &	operator[] (int n)

string &	operator= (const char *s)

string &	operator= (const string &s)

string &	operator= (const string *s)

string &	operator= (const std::string &s)

string &	operator= (const std::string *s)

string &	operator= (long long int)

string &	operator= (unsigned long long int)

string &	operator= (char n)

string &	operator= (unsigned char n)

string &	operator= (long n)

string &	operator= (unsigned long n)

string &	operator= (int n)

string &	operator= (unsigned int n)

string &	operator= (short n)

string &	operator= (unsigned short n)

string &	operator+= (const char *s)

string &	operator+= (const string &s)

string &	operator+= (const string *s)

string &	operator+= (const std::string &s)

string &	operator+= (const std::string *s)

string &	operator+= (long long int n)

string &	operator+= (unsigned long long int n)

string &	operator+= (long n)

string &	operator+= (unsigned long n)

string &	operator+= (int n)

string &	operator+= (unsigned int n)

string &	operator+= (short n)

string &	operator+= (unsigned short n)

string &	operator+= (char n)

string &	operator+= (unsigned char n)

string &	operator<< (const string &s)

string &	operator<< (const string *s)

string &	operator<< (const std::string &s)

string &	operator<< (const std::string *s)

string &	operator<< (const char *s)

string &	operator<< (long long int n)

string &	operator<< (unsigned long long int n)

string &	operator<< (long n)

string &	operator<< (unsigned long n)

string &	operator<< (int n)

string &	operator<< (unsigned int n)

string &	operator<< (short n)

string &	operator<< (unsigned short n)

string &	operator<< (char n)

string &	operator<< (unsigned char n)

size_t	operator>> (string *s)

size_t	operator>> (string &s)

size_t	operator>> (std::string *s)

size_t	operator>> (std::string &s)

size_t	operator>> (long long int &)

size_t	operator>> (unsigned long long int &)

size_t	operator>> (int &n)

size_t	operator>> (unsigned int &n)

size_t	operator>> (short &n)

size_t	operator>> (unsigned short &n)

size_t	operator>> (char &n)

size_t	operator>> (unsigned char &n)

bool	operator== (const string &s) const

bool	operator== (const string *s) const

bool	operator== (const char *s) const

bool	operator!= (const string &s) const

bool	operator!= (const string *s) const

bool	operator!= (const char *s) const

bool	operator< (const string &s) const

bool	operator> (const string &s) const

	operator const char * () const

	operator const void * () const

string &	push_back (char ch)

bool	equal (const string &s, bool case_sensitive=true) const

bool	begin_with (const char *s, bool case_sensitive=true) const

bool	begin_with (const char *s, size_t len, bool case_sensitive=true) const

bool	begin_with (const string &s, bool case_sensitive=true) const

bool	begin_with (const void *v, size_t len) const

bool	end_with (const char *s, bool case_sensitive=true) const

bool	end_with (const char *s, size_t len, bool case_sensitive=true) const

bool	end_with (const string &s, bool case_sensitive=true) const

bool	end_with (const void *v, size_t len) const

int	compare (const string &s) const

int	compare (const string *s) const

int	compare (const char *s, bool case_sensitive=true) const

int	compare (const void *ptr, size_t len) const

int	ncompare (const char *s, size_t len, bool case_sensitive=true) const

int	rncompare (const char *s, size_t len, bool case_sensitive=true) const

int	find_blank_line (int left_count=NULL, string buf=NULL)

string &	find_reset (void)

int	find (char n) const

char *	find (const char *needle, bool case_sensitive=true) const

char *	rfind (const char *needle, bool case_sensitive=true) const

string	left (size_t n)

string	right (size_t n)

size_t	scan_buf (void *buf, size_t size, bool move=false)

bool	scan_line (string &out, bool nonl=true, size_t *n=NULL, bool move=false)

size_t	scan_move ()

char *	buf_end (void)

void *	buf () const

char *	c_str () const

size_t	length () const

size_t	size () const

size_t	capacity () const

bool	empty () const

ACL_VSTRING *	vstring (void) const

string &	set_offset (size_t n)

string &	space (size_t n)

std::list< string > &	split (const char *sep, bool quoted=false)

std::vector< string > &	split2 (const char *sep, bool quoted=false)

std::pair< string, string > &	split_nameval (void)

string &	copy (const char *ptr)

string &	copy (const void *ptr, size_t len)

string &	memmove (const char *src)

string &	memmove (const char *src, size_t len)

string &	append (const string &s)

string &	append (const string *s)

string &	append (const char *s)

string &	append (const void *ptr, size_t len)

string &	prepend (const char *s)

string &	prepend (const void *ptr, size_t len)

string &	insert (size_t start, const void *ptr, size_t len)

string &	format (const char *fmt,...) ACL_CPP_PRINTF(2

string string &	vformat (const char *fmt, va_list ap)

string &	format_append (const char *fmt,...) ACL_CPP_PRINTF(2

string string &	vformat_append (const char *fmt, va_list ap)

string &	replace (char from, char to)

string &	truncate (size_t n)

string &	strip (const char *needle, bool each=false)

string &	trim_left_space ()

string &	trim_right_space ()

string &	trim_space ()

string &	trim_left_line ()

string &	trim_right_line ()

string &	trim_line ()

string &	clear ()

string &	lower (void)

string &	upper (void)

size_t	substr (string &out, size_t p=0, size_t len=0) const

string &	base64_encode (void)

string &	base64_encode (const void *ptr, size_t len)

string &	base64_decode (void)

string &	base64_decode (const char *s)

string &	base64_decode (const void *ptr, size_t len)

string &	url_encode (const char s, dbuf_pool dbuf=NULL)

string &	url_decode (const char s, dbuf_pool dbuf=NULL)

string &	hex_encode (const void *s, size_t len)

string &	hex_decode (const char *s, size_t len)

string &	basename (const char *path)

string &	dirname (const char *path)

template<typename T >
string	operator+ (T v)

静态 Public 成员函数
static string &	parse_int (int n)

static string &	parse_int (unsigned int n)

static string &	parse_int64 (long long int n)

static string &	parse_int64 (unsigned long long int n)

详细描述

该类为字符串处理类，支持大部分 std::string 中的功能，同时支持其不支持的一些功能；该类内部自动保证最后一个字符为 \0

在文件 string.hpp 第 20 行定义.

构造及析构函数说明

◆ string() [1/7]

acl::string::string	(	size_t	n,
		bool	bin
	)

构造函数

参数

n	{size_t} 初始时分配的内存大小
bin	{bool} 是否以二进制方式构建缓冲区对象，该值为 true 时，则当调用 += int\|int64\|short\|char 或调用 << int\|int64\|short\|char 时，则按二进制方式处理，否则按文本方式处理

◆ string() [2/7]

acl::string::string ( size_t n )

explicit

◆ string() [3/7]

acl::string::string ( void )

◆ string() [4/7]

acl::string::string ( const string & s )

构造函数

参数

s	{const string&} 源字符串对象，初始化后的类对象内部自动复制该字符串

◆ string() [5/7]

acl::string::string ( const char * s )

构造函数

参数

s	{const char*} 内部自动用该字符串初始化类对象，s 必须是以 \0 结尾

◆ string() [6/7]

acl::string::string	(	const void *	s,
		size_t	n
	)

构造函数

参数

s	{const char*} 源缓冲内容
n	{size_t} s 缓冲区数据长度

◆ string() [7/7]

acl::string::string	(	int	fd,
		size_t	max,
		size_t	n
	)

◆ ~string()

virtual acl::string::~string ( void )

virtual

成员函数说明

◆ append() [1/4]

string& acl::string::append ( const string & s )

将指定字符串添加在当前对象数据缓冲区数据的尾部

参数

s	{const string&} 源数据对象引用

返回: {string&} 当前对象的引用

◆ append() [2/4]

string& acl::string::append ( const string * s )

将指定字符串添加在当前对象数据缓冲区数据的尾部

参数

s	{const string&} 源数据对象指针

返回: {string&} 当前对象的引用

◆ append() [3/4]

string& acl::string::append ( const char * s )

将指定字符串添加在当前对象数据缓冲区数据的尾部

参数

s	{const string&} 源数据对象指针

返回: {string&} 当前对象的引用

◆ append() [4/4]

string& acl::string::append	(	const void *	ptr,
		size_t	len
	)

将指定缓冲区中的数据添加在当前对象数据缓冲区数据的尾部

参数

ptr	{const void*} 源数据对象指针
len	{size_t} ptr 数据长度

返回: {string&} 当前对象的引用

◆ base64_decode() [1/3]

string& acl::string::base64_decode ( void )

如果当前对象的缓冲区中的数据是经 base64 编码的，则此函数将这些数据进行解码

返回: {string&} 当前对象的引用，如果解码出错，则内部缓冲区会被自动清空，调用 string::empty() 返回 true

◆ base64_decode() [2/3]

string& acl::string::base64_decode ( const char * s )

将输入的 base64 编码的数据进行解码并存入当前对象的缓冲区中

参数

s	{const char*} 经 base64 编码的源数据

返回: {string&} 当前对象的引用，如果解码出错，则内部缓冲区会被自动清空，调用 string::empty() 返回 true

◆ base64_decode() [3/3]

string& acl::string::base64_decode	(	const void *	ptr,
		size_t	len
	)

将输入的 base64 编码的数据进行解码并存入当前对象的缓冲区中

参数

ptr	{const void*} 经 base64 编码的源数据
len	{size_t} ptr 数据长度

返回: {string&} 当前对象的引用，如果解码出错，则内部缓冲区会被自动清空，调用 string::empty() 返回 true

◆ base64_encode() [1/2]

string& acl::string::base64_encode ( void )

将当前对象的数据缓冲区中的数据进行 base64 转码

返回: {string&} 当前对象的引用

◆ base64_encode() [2/2]

string& acl::string::base64_encode	(	const void *	ptr,
		size_t	len
	)

将输入的源数据进行 base64 转码并存入当前对象的缓冲区中

参数

ptr	{const void*} 源数据的地址
len	{size_t} 源数据长度

返回: {string&} 当前对象的引用

◆ basename()

string& acl::string::basename ( const char * path )

从文件全路径中提取文件名

参数

path	{const char*} 文件全路径字符串，非空字符串

返回: {string&} 当前对象的引用

◆ begin_with() [1/4]

bool acl::string::begin_with	(	const char *	s,
		bool	case_sensitive = `true`
	)		const

检查当前 string 对象是否以指定的字符串开始

参数

s	{const char*}
case_sensitive	{bool} 是否区分大小写

返回: {bool}

◆ begin_with() [2/4]

bool acl::string::begin_with	(	const char *	s,
		size_t	len,
		bool	case_sensitive = `true`
	)		const

◆ begin_with() [3/4]

bool acl::string::begin_with	(	const string &	s,
		bool	case_sensitive = `true`
	)		const

◆ begin_with() [4/4]

bool acl::string::begin_with	(	const void *	v,
		size_t	len
	)		const

◆ buf()

void* acl::string::buf ( ) const

返回当前对象缓冲区的起始地址

返回: {void*} 返回地址永远非空

◆ buf_end()

char* acl::string::buf_end ( void )

返回当前对象缓冲区中第一个不含数据的尾部地址

返回: {char*} 返回值为 NULL 则说明内部数据为空，即 empty() == true

◆ c_str()

char* acl::string::c_str ( ) const

以字符串方式返回当前对象缓冲区的起始地址

返回: {char*} 返回地址永远非空

被这些函数引用 acl::deserialize() , 以及 acl::redis_pipeline_channel::get_addr().

这是这个函数的调用关系图:

◆ capacity()

size_t acl::string::capacity ( ) const

返回当前对象的缓冲区的空间长度，该值 >= 缓冲区内数据长度

返回: {size_t} 返回值 > 0

◆ clear()

string& acl::string::clear ( )

清空当前对象的数据缓冲区

返回: {string&} 当前对象的引用

◆ compare() [1/4]

int acl::string::compare ( const string & s ) const

比较两个字符串对象的内容是否相同（区分大小写）

参数

s	{const string&} 输入的字符串对象的引用

返回: {int} 0：表示二者相同； > 0：当前字符串内容大于输入的内容； < 0 ：当前字符串内容小于输入的内容

◆ compare() [2/4]

int acl::string::compare ( const string * s ) const

比较两个字符串对象的内容是否相同（区分大小写）

参数

s	{const string&} 输入的字符串对象的指针

返回: {int} 0：表示二者相同； > 0：当前字符串内容大于输入的内容； < 0 ：当前字符串内容小于输入的内容

◆ compare() [3/4]

int acl::string::compare	(	const char *	s,
		bool	case_sensitive = `true`
	)		const

比较两个字符串的内容是否相同

参数

s	{const string&} 输入的字符串对象的引用
case_sensitive	{bool} 为 true 表示区分大小写

返回: {int} 0：表示二者相同； > 0：当前字符串内容大于输入的内容； < 0 ：当前字符串内容小于输入的内容

◆ compare() [4/4]

int acl::string::compare	(	const void *	ptr,
		size_t	len
	)		const

比较当前对象的缓冲区内容是否与所给的缓冲区的内容相同

参数

ptr	{const void*} 输入的缓冲区地址
len	{size_t} ptr 的缓冲区内数据长度

返回: {int} 返回结果含义如下: 0：表示二者相同；

0：当前对象缓冲区内容大于输入的内容；

< 0 ：当前对象缓冲内容小于输入的内容

◆ copy() [1/2]

string& acl::string::copy ( const char * ptr )

将字符串拷贝到当前对象的缓冲区中

参数

ptr	{const char*} 源字符串地址，需以 '\0' 结束

返回: {string&} 当前对象的引用

◆ copy() [2/2]

string& acl::string::copy	(	const void *	ptr,
		size_t	len
	)

将源数据的定长数据拷贝至当前对象的缓冲区中

参数

ptr	{const void*} 源数据地址
len	{size_t} ptr 源数据长度

返回: {string&} 当前对象的引用

◆ dirname()

string& acl::string::dirname ( const char * path )

从文件全路径中提取文件所在目录

参数

path	{const char*} 文件全路径字符串，非空字符串

返回: {string&} 当前对象的引用

◆ empty()

bool acl::string::empty ( ) const

判断当前对象的缓冲区内数据长度是否为 0

返回: {bool} 返回 true 表示数据为空

◆ end_with() [1/4]

bool acl::string::end_with	(	const char *	s,
		bool	case_sensitive = `true`
	)		const

检查当前 string 对象是否以指定的字符串结束

参数

s	{const char*}
case_sensitive	{bool} 是否区分大小写

返回: {bool}

◆ end_with() [2/4]

bool acl::string::end_with	(	const char *	s,
		size_t	len,
		bool	case_sensitive = `true`
	)		const

◆ end_with() [3/4]

bool acl::string::end_with	(	const string &	s,
		bool	case_sensitive = `true`
	)		const

◆ end_with() [4/4]

bool acl::string::end_with	(	const void *	v,
		size_t	len
	)		const

◆ equal()

bool acl::string::equal	(	const string &	s,
		bool	case_sensitive = `true`
	)		const

比较两个字符串对象的内容是否相同（区分大小写）

参数

s	{const string&} 输入的字符串对象的引用
case_sensitive	{bool} 为 true 表示区分大小写

返回: {bool} 返回 true 表示二者相等

◆ find() [1/2]

int acl::string::find ( char n ) const

查找指定字符在当前对象缓冲区的位置（下标从 0 开始）

参数

n	{char} 要查找的有符号字符

返回: {int} 字符在缓冲区中的位置，若返回值 < 0 则表示不存在

◆ find() [2/2]

char* acl::string::find	(	const char *	needle,
		bool	case_sensitive = `true`
	)		const

查找指定字符串在当前对象缓冲区的起始位置（下标从 0 开始）

参数

needle	{const char*} 要查找的有符号字符串
case_sensitive	{bool} 为 true 表示区分大小写

返回: {char*} 字符串在缓冲区中的起始位置，返回空指针则表示不存在

◆ find_blank_line()

int acl::string::find_blank_line	(	int *	left_count = `NULL`,
		string *	buf = `NULL`
	)

在当前字符串缓冲区中查找空行的位置，可以循环调用本方法以获得所有的符合条件的内容

参数

left_count	{int*} 当该指针非空时存储当前字符串剩余的数据长度
buf	{string*} 当找到空行时，则将上一次空行(不含该空行)和本次空行(包含该空行)之间的数据存放于该缓冲区内，注：内部并不负责清空该缓冲区，因为采用数据追加方式

返回: {int} 返回 0 表示未找到空行；返回值 > 0 表示空行的下一个位置(因为需要找到一个空行返回的是该空行的下一个位置，所以若找到空行则返回值一定大于 0)；返回值 < 0 表示内部出错

◆ find_reset()

string& acl::string::find_reset ( void )

重置内部查询状态，当需要重新开始调用 find_blank_line 时需要调用本方法以重置内部查询状态

返回: {string&}

◆ format()

string& acl::string::format	(	const char *	fmt,
			...
	)

带格式方式的添加数据（类似于 sprintf 接口方式）

参数

fmt	{const char*} 格式字符串
...	变参数据

返回: {string&} 当前对象的引用

◆ format_append()

string& acl::string::format_append	(	const char *	fmt,
			...
	)

带格式方式在当前对象的尾部添加数据

参数

fmt	{const char*} 格式字符串
...	变参数据

返回: {string&} 当前对象的引用

◆ get_bin()

bool acl::string::get_bin ( ) const

判断当前字符串类对象是否为二进制处理方式

返回: {bool} 返回值为 true 时则表示为二进制方式

◆ get_max()

int acl::string::get_max ( void ) const

返回当前缓冲区的最大长度限制，若返回值 <= 0 则表示没有限制

返回: {int}

◆ hex_decode()

string& acl::string::hex_decode	(	const char *	s,
		size_t	len
	)

将源数据进行 H2B 解码并存入当前对象的缓冲区中

参数

s	{const char*} 源数据地址
len	{size_t} 源数据长度

返回: {string&} 当前对象的引用

◆ hex_encode()

string& acl::string::hex_encode	(	const void *	s,
		size_t	len
	)

将源数据进行 H2B 编码并存入当前对象的缓冲区中

参数

s	{const void*} 源数据地址
len	{size_t} 源数据长度

返回: {string&} 当前对象的引用

◆ insert()

string& acl::string::insert	(	size_t	start,
		const void *	ptr,
		size_t	len
	)

将内存数据插入指定下标位置开始的当前对象缓冲区中

参数

start	{size_t} 当前对象缓冲区的开始插入下标值
ptr	{const void*} 内存数据的地址
len	{size_t} 内存数据的长度

返回: {string&} 当前对象的引用

◆ left()

string acl::string::left ( size_t n )

返回从当前字符串对象中缓冲区指定位置以左的内容

参数

n	{size_t} 下标位置，当该值大于等于当前字符串的数据长度时，则返回整个字符串对象；返回值不包含该值指定位置的字符内容

返回: {string} 返回值为一完整的对象，不需要单独释放，该函数的效率可能并不太高

◆ length()

size_t acl::string::length ( ) const

返回当前对象字符串的长度（不含\0）

返回: {size_t} 返回值 >= 0

◆ lower()

string& acl::string::lower ( void )

将当前对象的数据缓冲区中的数据均转为小写

返回: {string&} 当前对象的引用

被这些函数引用 acl::http_server_impl::Service().

这是这个函数的调用关系图:

◆ memmove() [1/2]

string& acl::string::memmove ( const char * src )

将源字符串的数据移动至当前对象的缓冲区中，内部会自动判断源数据地址是否就在当前对象的缓冲区中

参数

src	{const char*} 源数据地址

返回: {string&} 当前对象的引用

◆ memmove() [2/2]

string& acl::string::memmove	(	const char *	src,
		size_t	len
	)

将源字符串的数据移动至当前对象的缓冲区中，内部会自动判断源数据地址是否就在当前对象的缓冲区中

参数

src	{const char*} 源数据地址
len	{size_t} 移动数据的长度

返回: {string&} 当前对象的引用

◆ ncompare()

int acl::string::ncompare	(	const char *	s,
		size_t	len,
		bool	case_sensitive = `true`
	)		const

比较当前对象缓冲区内容是否与所给的缓冲区的内容相同，限定比较数据长度

参数

s	{const void*} 输入的缓冲区地址
len	{size_t} ptr 的缓冲区内数据长度
case_sensitive	{bool} 为 true 表示区分大小写

返回: {int} 0：表示二者相同； > 0：当前对象缓冲区内容大于输入的内容； < 0 ：当前对象缓冲内容小于输入的内容

◆ operator const char *()

acl::string::operator const char * ( ) const

将当前对象直接转为字符串指针（即将内部缓冲区直接导出）

返回: {const char*} 返回值永远为非空指针，有可能为空串

◆ operator const void *()

acl::string::operator const void * ( ) const

将当前字符串对象直接转为通用指针（即将内部缓冲区直接导出）

返回: {const char*} 返回值永远为非空指针

◆ operator!=() [1/3]

bool acl::string::operator!= ( const string & s ) const

判断当前对象的内容与所给的字符串对象内容是否不等（内部区分大小写）

参数

s	{const string&} 输入的字符串对象引用

返回: {bool} 返回 true 表示字符串内容不同

◆ operator!=() [2/3]

bool acl::string::operator!= ( const string * s ) const

判断当前对象的内容与所给的字符串对象内容是否不等（内部区分大小写）

参数

s	{const string&} 输入的字符串对象指针

返回: {bool} 返回 true 表示字符串内容不同

◆ operator!=() [3/3]

bool acl::string::operator!= ( const char * s ) const

判断当前对象的内容与所给的字符串内容是否不等（内部区分大小写）

参数

s	{const string&} 输入的字符串对象指针

返回: {bool} 返回 true 表示字符串内容不同

◆ operator+()

template<typename T >

string acl::string::operator+ ( T v )

inline

模板函数，可用在以下场景: string s1, s2; T v; s1 = s2 + v;

在文件 string.hpp 第 1282 行定义.

         {
                 string s(*this);
                 s += v;
                 return s;
         }

◆ operator+=() [1/15]

string& acl::string::operator+= ( const char * s )

向目标字符串对象尾部添加字符串

参数

s	{const char*} 源字符串指针

返回: {string&} 目标字符串对象的引用

◆ operator+=() [2/15]

string& acl::string::operator+= ( const string & s )

向目标字符串对象尾部添加字符串

参数

s	{const string&} 源字符串对象引用

返回: {string&} 目标字符串对象的引用

◆ operator+=() [3/15]

string& acl::string::operator+= ( const string * s )

向目标字符串对象尾部添加字符串

参数

s	{const string*} 源字符串对象指针

返回: {string&} 目标字符串对象的引用

◆ operator+=() [4/15]

string& acl::string::operator+= ( const std::string & s )

向目标字符串对象尾部添加字符串

参数

s	{const std::string&} 源字符串对象引用

返回: {string&} 目标字符串对象的引用

◆ operator+=() [5/15]

string& acl::string::operator+= ( const std::string * s )

向目标字符串对象尾部添加字符串

参数

s	{const std::string*} 源字符串对象指针

返回: {string&} 目标字符串对象的引用

◆ operator+=() [6/15]

string& acl::string::operator+= ( long long int n )

◆ operator+=() [7/15]

string& acl::string::operator+= ( unsigned long long int n )

◆ operator+=() [8/15]

string& acl::string::operator+= ( long n )

向目标字符串对象尾部添加有符号长整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号长整数

返回: {string&} 目标字符串对象的引用

◆ operator+=() [9/15]

string& acl::string::operator+= ( unsigned long n )

向目标字符串对象尾部添加无符号长整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号长整数

返回: {string&} 目标字符串对象的引用

◆ operator+=() [10/15]

string& acl::string::operator+= ( int n )

向目标字符串对象尾部添加有符号整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号整数

返回: {string&} 目标字符串对象的引用

◆ operator+=() [11/15]

string& acl::string::operator+= ( unsigned int n )

向目标字符串对象尾部添加无符号整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号整数

返回: {string&} 目标字符串对象的引用

◆ operator+=() [12/15]

string& acl::string::operator+= ( short n )

向目标字符串对象尾部添加有符号短整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号短整数

返回: {string&} 目标字符串对象的引用

◆ operator+=() [13/15]

string& acl::string::operator+= ( unsigned short n )

向目标字符串对象尾部添加无符号短整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号短整数

返回: {string&} 目标字符串对象的引用

◆ operator+=() [14/15]

string& acl::string::operator+= ( char n )

向目标字符串对象尾部添加有符号字符，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号字符

返回: {string&} 目标字符串对象的引用

◆ operator+=() [15/15]

string& acl::string::operator+= ( unsigned char n )

向目标字符串对象尾部添加无符号字符，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号字符

返回: {string&} 目标字符串对象的引用

◆ operator<()

bool acl::string::operator< ( const string & s ) const

判断当前对象的内容是否小于所给的字符串对象内容（内部区分大小写）

参数

s	{const string&} 输入的字符串对象引用

返回: {bool} 返回 true 表示当前字符串对象的内容小于输入的字符串对象内容

◆ operator<<() [1/15]

string& acl::string::operator<< ( const string & s )

向目标字符串对象尾部添加字符串

参数

s	{const string&} 源字符串对象引用

返回: {string&} 目标字符串对象的引用

◆ operator<<() [2/15]

string& acl::string::operator<< ( const string * s )

向目标字符串对象尾部添加字符串

参数

s	{const string*} 源字符串对象指针

返回: {string&} 目标字符串对象的引用

◆ operator<<() [3/15]

string& acl::string::operator<< ( const std::string & s )

向目标字符串对象尾部添加字符串

参数

s	{const std::string&} 源字符串对象引用

返回: {string&} 目标字符串对象的引用

◆ operator<<() [4/15]

string& acl::string::operator<< ( const std::string * s )

向目标字符串对象尾部添加字符串

参数

s	{const std::string*} 源字符串对象指针

返回: {string&} 目标字符串对象的引用

◆ operator<<() [5/15]

string& acl::string::operator<< ( const char * s )

向目标字符串对象尾部添加字符串

参数

s	{const char*} 源字符串指针

返回: {string&} 目标字符串对象的引用

◆ operator<<() [6/15]

string& acl::string::operator<< ( long long int n )

◆ operator<<() [7/15]

string& acl::string::operator<< ( unsigned long long int n )

◆ operator<<() [8/15]

string& acl::string::operator<< ( long n )

向目标字符串对象尾部添加有符号长整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号长整数

返回: {string&} 目标字符串对象的引用

◆ operator<<() [9/15]

string& acl::string::operator<< ( unsigned long n )

向目标字符串对象尾部添加无符号长整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号长整数

返回: {string&} 目标字符串对象的引用

◆ operator<<() [10/15]

string& acl::string::operator<< ( int n )

向目标字符串对象尾部添加有符号整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号整数

返回: {string&} 目标字符串对象的引用

◆ operator<<() [11/15]

string& acl::string::operator<< ( unsigned int n )

向目标字符串对象尾部添加无符号整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号整数

返回: {string&} 目标字符串对象的引用

◆ operator<<() [12/15]

string& acl::string::operator<< ( short n )

向目标字符串对象尾部添加有符号短整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号短整数

返回: {string&} 目标字符串对象的引用

◆ operator<<() [13/15]

string& acl::string::operator<< ( unsigned short n )

向目标字符串对象尾部添加无符号短整型数字，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号短整数

返回: {string&} 目标字符串对象的引用

◆ operator<<() [14/15]

string& acl::string::operator<< ( char n )

向目标字符串对象尾部添加有符号字符，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源有符号字符

返回: {string&} 目标字符串对象的引用

◆ operator<<() [15/15]

string& acl::string::operator<< ( unsigned char n )

向目标字符串对象尾部添加无符号字符，当为目标字符串对象为二进制方式时，则按二进制数字方式添加；否则按文本方式添加

参数

n	{long} 源无符号字符

返回: {string&} 目标字符串对象的引用

◆ operator=() [1/15]

string& acl::string::operator= ( const char * s )

对目标字符串类对象赋值

参数

s	{const char*} 源字符串

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [2/15]

string& acl::string::operator= ( const string & s )

对目标字符串类对象赋值

参数

s	{const string&} 源字符串对象

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [3/15]

string& acl::string::operator= ( const string * s )

对目标字符串类对象赋值

参数

s	{const string*} 源字符串对象

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [4/15]

string& acl::string::operator= ( const std::string & s )

对目标字符串类对象赋值

参数

s	{const std::string&} 源字符串对象

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [5/15]

string& acl::string::operator= ( const std::string * s )

对目标字符串类对象赋值

参数

s	{const std::string*} 源字符串对象

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [6/15]

string& acl::string::operator= ( long long int )

◆ operator=() [7/15]

string& acl::string::operator= ( unsigned long long int )

◆ operator=() [8/15]

string& acl::string::operator= ( char n )

对目标字符串类对象赋值

参数

n	{char} 源有符号字符；若字符串对象的当前状态为二进制模式，则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [9/15]

string& acl::string::operator= ( unsigned char n )

对目标字符串类对象赋值

参数

n	{char} 源无符号字符；若对象的当前状态为二进制模式，则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [10/15]

string& acl::string::operator= ( long n )

对目标字符串类对象赋值

参数

n	{char} 源有符号长整型；若对象当前状态为二进制模式，则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [11/15]

string& acl::string::operator= ( unsigned long n )

对目标字符串类对象赋值

参数

n	{char} 源无符号长整型；若字对象的当前状态为二进制模式，则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [12/15]

string& acl::string::operator= ( int n )

对目标字符串类对象赋值

参数

n	{char} 源有符号整型；若字符串对象的当前状态为二进制模式，则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [13/15]

string& acl::string::operator= ( unsigned int n )

对目标字符串类对象赋值

参数

n	{char} 源无符号整型；若字符串对象的当前状态为二进制模式，则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [14/15]

string& acl::string::operator= ( short n )

对目标字符串类对象赋值

参数

n	{char} 源有符号短整型；若字符串对象的当前状态为二进制模式, 则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator=() [15/15]

string& acl::string::operator= ( unsigned short n )

对目标字符串类对象赋值

参数

n	{char} 源无符号短整型；若对象的当前状态为二进制模式，则该函数便会以二进制方式赋值给字符串对象，否则以文本方式赋值给字符串对象；关于二进制模式还是文本方式，其含义参见 set_bin(bool)

返回: {string&} 返回当前对象的引用，便于对该类对象连续进行操作

◆ operator==() [1/3]

bool acl::string::operator== ( const string & s ) const

判断当前对象的内容与所给的字符串对象内容是否相等（内部区分大小写）

参数

s	{const string&} 输入的字符串对象引用

返回: {bool} 返回 true 表示字符串内容相同

◆ operator==() [2/3]

bool acl::string::operator== ( const string * s ) const

判断当前对象的内容与所给的字符串对象内容是否相等（内部区分大小写）

参数

s	{const string&} 输入的字符串对象指针

返回: {bool} 返回 true 表示字符串内容相同

◆ operator==() [3/3]

bool acl::string::operator== ( const char * s ) const

判断当前对象的内容与所给的字符串内容是否相等（内部区分大小写）

参数

s	{const string&} 输入的字符串对象指针

返回: {bool} 返回 true 表示字符串内容相同

◆ operator>()

bool acl::string::operator> ( const string & s ) const

判断当前对象的内容是否大于所给的字符串对象内容（内部区分大小写）

参数

s	{const string&} 输入的字符串对象引用

返回: {bool} 返回 true 表示当前字符串对象的内容大于输入的字符串对象内容

◆ operator>>() [1/12]

size_t acl::string::operator>> ( string * s )

将字符串对象中的内容赋予目标字符串对象

参数

s	{string*} 目标字符串对象

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [2/12]

size_t acl::string::operator>> ( string & s )

将字符串对象中的内容赋予目标字符串对象

参数

s	{string&} 目标字符串对象

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [3/12]

size_t acl::string::operator>> ( std::string * s )

将字符串对象中的内容赋予目标字符串对象

参数

s	{std::string*} 目标字符串对象

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [4/12]

size_t acl::string::operator>> ( std::string & s )

将字符串对象中的内容赋予目标字符串对象

参数

s	{std::string&} 目标字符串对象

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [5/12]

size_t acl::string::operator>> ( long long int & )

◆ operator>>() [6/12]

size_t acl::string::operator>> ( unsigned long long int & )

◆ operator>>() [7/12]

size_t acl::string::operator>> ( int & n )

将字符串对象中的内容赋予目标 32 位有符号整数

参数

n	{string*} 目标 32 位有符号整数

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [8/12]

size_t acl::string::operator>> ( unsigned int & n )

将字符串对象中的内容赋予目标 32 位无符号整数

参数

n	{string*} 目标 32 位无符号整数

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [9/12]

size_t acl::string::operator>> ( short & n )

将字符串对象中的内容赋予目标 16 位有符号整数

参数

n	{string*} 目标 16 位有符号整数

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [10/12]

size_t acl::string::operator>> ( unsigned short & n )

将字符串对象中的内容赋予目标 16 位无符号整数

参数

n	{string*} 目标 16 位无符号整数

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [11/12]

size_t acl::string::operator>> ( char & n )

将字符串对象中的内容赋予目标 8 位有符号字符

参数

n	{string*} 目标 16 位有符号字符

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator>>() [12/12]

size_t acl::string::operator>> ( unsigned char & n )

将字符串对象中的内容赋予目标 8 位无符号字符

参数

n	{string*} 目标 16 位无符号字符

返回: {size_t} 返回拷贝的实际字节数，empty() == true 时，则返回 0

◆ operator[]() [1/4]

char acl::string::operator[] ( size_t n ) const

根据字符数组下标获得指定位置的字符，输入参数必须为合法值，否则则内部产生断言

参数

n	{size_t} 指定的位置（该值 >= 0 且 < 字符串长度)，如果越界则产生断言

返回: {char} 返回指定位置的字符

◆ operator[]() [2/4]

char acl::string::operator[] ( int n ) const

根据字符数组下标获得指定位置的字符，输入参数必须为合法值，否则则内部产生断言

参数

n	{int} 指定的位置（该值 >= 0 且 < 字符串长度)，如果越界，则产生断言

返回: {char} 返回指定位置的字符

◆ operator[]() [3/4]

char& acl::string::operator[] ( size_t n )

左值赋值重载，用户可以直接使用对象的数组下标进行赋值，如果下标组值越界，则内部会自动扩充缓冲区空间

参数

n	{size_t} 数组下标位置

返回: {char&}

◆ operator[]() [4/4]

char& acl::string::operator[] ( int n )

左值赋值重载，用户可以直接使用对象的数组下标进行赋值，如果下标组值越界，则内部会自动扩充缓冲区空间

参数

n	{int} 数组下标位置，该值必须 >= 0

返回: {char&}

◆ parse_int() [1/2]

static string& acl::string::parse_int ( int n )

static

将 32 位有符号整数转为字符串存（内部使用了线程局部变量）

参数

n	{int} 32 位有符号整数

返回: {string&} 转换结果对象的引用，其引用了内部的一个线程局部变量

◆ parse_int() [2/2]

static string& acl::string::parse_int ( unsigned int n )

static

将 32 位无符号整数转为字符串存（内部使用了线程局部变量）

参数

n	{int} 32 位无符号整数

返回: {string&} 转换结果对象的引用，其引用了内部的一个线程局部变量

◆ parse_int64() [1/2]

static string& acl::string::parse_int64 ( long long int n )

static

将 64 位有符号整数转为字符串存（内部使用了线程局部变量）

参数

n	{long long int} 64 位有符号整数

返回: {string&} 转换结果对象的引用，其引用了内部的一个线程局部变量

◆ parse_int64() [2/2]

static string& acl::string::parse_int64 ( unsigned long long int n )

static

将 64 位无符号整数转为字符串存（内部使用了线程局部变量）

参数

n	{unsigned long long int} 64 位无符号整数

返回: {string&} 转换结果对象的引用，其引用了内部的一个线程局部变量

◆ prepend() [1/2]

string& acl::string::prepend ( const char * s )

将指定字符串数据添加在当前对象数据缓冲区数据的首部

参数

s	{const char*} 源数据地址

返回: {string&} 当前对象的引用

◆ prepend() [2/2]

string& acl::string::prepend	(	const void *	ptr,
		size_t	len
	)

将指定内存数据添加在当前对象数据缓冲区数据的首部

参数

ptr	{const void*} 源数据地址
len	{size_t} ptr 数据长度

返回: {string&} 当前对象的引用

◆ push_back()

string& acl::string::push_back ( char ch )

将一个有符号字符添加进当前字符串对象的尾部

参数

ch	{char} 有符号字符

返回: {string&} 当前字符串对象的引用

◆ replace()

string& acl::string::replace	(	char	from,
		char	to
	)

将当前对象中的数据的字符进行替换

参数

from	{char} 源字符
to	{char} 目标字符

返回: {string&} 当前对象的引用

◆ rfind()

char* acl::string::rfind	(	const char *	needle,
		bool	case_sensitive = `true`
	)		const

从尾部向前查找指定字符串在当前对象缓冲区的起始位置（下标从 0 开始）

参数

needle	{const char*} 要查找的有符号字符串
case_sensitive	{bool} 为 true 表示区分大小写

返回: {char*} 字符串在缓冲区中的起始位置，若返回值为空指针则表示不存在

◆ right()

string acl::string::right ( size_t n )

返回从当前字符串对象中缓冲区指定位置以右的内容

参数

n	{size_t} 下标位置，当该值大于等于当前字符串的数据长度时，则返回的字符串对象内容为空；返回值不包含该值指定位置的字符内容

返回: {const string} 返回值为一完整的对象，不需要单独释放，该函数的效率可能并不太高

◆ rncompare()

int acl::string::rncompare	(	const char *	s,
		size_t	len,
		bool	case_sensitive = `true`
	)		const

从尾部向前比较当前对象的缓冲区内容是否与所给的缓冲区的内容相同，限定比较数据长度

参数

s	{const void*} 输入的缓冲区地址
len	{size_t} ptr 的缓冲区内数据长度
case_sensitive	{bool} 为 true 表示区分大小写

返回: {int} 0：表示二者相同；

0：当前对象缓冲区内容大于输入的内容；

< 0 ：当前对象缓冲内容小于输入的内容

◆ scan_buf()

size_t acl::string::scan_buf	(	void *	buf,
		size_t	size,
		bool	move = `false`
	)

将当前对象的缓冲内容拷贝一部分数据至目标缓冲内

参数

buf	{void*} 目标缓冲区地址
size	{size_t} buf 缓冲区长度
move	{bool} 在拷贝完数据后，是否需要将后面的数据向前移动并覆盖前面的已拷贝的数据

返回: {size_t} 返回拷贝的实际字节数，当 empty() == true 时，则返回 0

◆ scan_line()

bool acl::string::scan_line	(	string &	out,
		bool	nonl = `true`,
		size_t *	n = `NULL`,
		bool	move = `false`
	)

从当前对象的缓冲区中拷贝一行数据(包含"\r\n")至目标缓冲区内，当数据被拷贝至目标缓冲区后，在源缓冲区内未被拷贝的数据会发生移动并覆盖被拷贝的数据区域

参数

out	{string&} 目标缓冲区，函数内部不会先自动清空该缓冲区
nonl	{bool} 返回的一行数据是否去掉尾部的 "\r\n" 或 "\n"
n	{size_t*} 该参数为非空指针时，则存储拷贝到的数据长度；当读到一个空行且 nonl 为 true 时，则该地址存储 0
move	{bool} 在拷贝完数据后，是否需要将后面的数据向前移动并覆盖前面的已拷贝的数据

返回: {bool} 是否拷贝了一个完整行数据，如果返回 false 还需要根据 empty() == true 来判断当前缓冲区中是否还有数据

◆ scan_move()

size_t acl::string::scan_move ( )

当使用 scan_xxx 类方法对缓冲区进行操作时未指定 move 动作，则调用本函数可以使缓冲区内剩余的数据向前移动至缓冲区首部

返回: {size_t} 移动的字节数

◆ set_bin()

string& acl::string::set_bin ( bool bin )

设置字符串类对象为二进制处理模式

参数

bin	{bool} 当该值为 true 时，则设置字符串类对象为二进制处理方式；否则为文本方式；为 true 时，则当调用 += int\|int64\|short\|char 或调用 << int\|int64\|short\|char 时，则按二进制方式处理，否则按文本方式处理

返回: {string&}

◆ set_max()

string& acl::string::set_max ( int max )

设置缓冲区的最大长度，以避免缓冲区溢出

参数

max {int}

返回: {string&}

◆ set_offset()

string& acl::string::set_offset ( size_t n )

将当前对象的缓冲区的下标位置移至指定位置

参数

n	{size_t} 目标下标位置，当该值 >= capacity 时，内部会重新分配更大些的内存

返回: {string&} 当前对象的引用

◆ size()

size_t acl::string::size ( ) const

返回当前对象字符串的长度（不含\0），功能与 length 相同

返回: {size_t} 返回值 >= 0

被这些函数引用 acl::http_server_impl::Service().

这是这个函数的调用关系图:

◆ space()

string& acl::string::space ( size_t n )

调用该函数可以预先保证所需要的缓冲区大小

参数

n	{size_t} 希望的缓冲区空间大小值

返回: {string&} 当前对象的引用

◆ split()

std::list<string>& acl::string::split	(	const char *	sep,
		bool	quoted = `false`
	)

将当前对象存储的字符串进行分割

参数

sep	{const char*} 进行分割时的分割标记
quoted	{bool} 当为 true 时，则对于由单/双引号引起来的字符串内容，不做分割，但此时要求 sep 中不得存在单/双号

返回: {std::list<string>&} 返回 list 格式的分割结果，返回的结果不需要释放，其引用了当前对象的一个内部指针

◆ split2()

std::vector<string>& acl::string::split2	(	const char *	sep,
		bool	quoted = `false`
	)

将当前对象存储的字符串进行分割

参数

sep	{const char*} 进行分割时的分割标记
quoted	{bool} 当为 true 时，则对于由单/双引号引起来的字符串内容，不做分割，但此时要求 sep 中不得存在单/双号

返回: {std::vector<string>&} 返回 vector 格式的分割结果，返回的结果不需要释放，其引用了当前对象的一个内部指针

◆ split_nameval()

std::pair<string, string>& acl::string::split_nameval ( void )

以 '=' 为分隔符将当前对象存储的字符串分割成 name/value 对，分割时会自动去掉源字符串的起始处、结尾处以及分隔符 '=' 两边的空格及 TAB

返回: {std::pair<string, string>&} 如果当前对象存储的字符串不符合分割条件（即不是严格的 name=value格式），则返回的结果中字符串对象为空串,返回的结果不需要释放，其引用了当前对象的一个内部地址

◆ strip()

string& acl::string::strip	(	const char *	needle,
		bool	each = `false`
	)

在当前对象的缓冲区数据中去掉指定的字符串内容，在处理过程中会发生数据移动情况

参数

needle	{const char*} 指定需要去掉的字符串数据
each	{bool} 当为 true 时，则每一个出现在 needle 中的字符都会在当前对象的缓存区中去掉；否则，仅在当前对象缓冲区中去掉完整的 needle 字符串

返回: {string&} 当前对象的引用如 acl::string s("hello world!"); 若 s.strip("hel", true), 则结果为： s == "o word!" 若 s.strip("hel", false), 则结果为: s = "lo world!"

◆ substr()

size_t acl::string::substr	(	string &	out,
		size_t	p = `0`,
		size_t	len = `0`
	)		const

从当前缓冲区中将指定偏移量指定长度的数据拷贝至目标缓冲区中

参数

out	{string&} 目标缓冲区，内部采用追加方式，并不清空该对象
p	{size_t} 当前缓冲区的起始位置
len	{size_t} 从 p 起始位置开始拷贝的数据量，当该值为 0 时则拷贝指定 p 位置后所有的数据，否则拷贝指定长度的数据，若指定的数据长度大于实际要拷贝的长度，则仅拷贝实际存在的数据

返回: {size_t} 返回拷贝的实际数据长度，p 越界时则该返回值为 0

◆ trim_left_line()

string& acl::string::trim_left_line ( )

将当前对象缓冲区左边的回车换行符去掉

返回: {string&} 当前对象的引用

◆ trim_left_space()

string& acl::string::trim_left_space ( )

将当前对象缓冲区左边的空白（包含空格及TAB）去掉

返回: {string&} 当前对象的引用

◆ trim_line()

string& acl::string::trim_line ( )

将当前对象缓冲区中所有的回车换行符去掉

返回: {string&} 当前对象的引用

◆ trim_right_line()

string& acl::string::trim_right_line ( )

将当前对象缓冲区右边的回车换行符去掉

返回: {string&} 当前对象的引用

◆ trim_right_space()

string& acl::string::trim_right_space ( )

将当前对象缓冲区右边的空白（包含空格及TAB）去掉

返回: {string&} 当前对象的引用

◆ trim_space()

string& acl::string::trim_space ( )

将当前对象缓冲区中所有的空白（包含空格及TAB）去掉

返回: {string&} 当前对象的引用

◆ truncate()

string& acl::string::truncate ( size_t n )

将当前对象的数据截短，缓冲区内部移动下标指针地址

参数

n	{size_t} 数据截短后的数据长度，如果该值 >= 当前缓冲区数据长度，则内部不做任何变化

返回: {string&} 当前对象的引用

◆ upper()

string& acl::string::upper ( void )

将当前对象的数据缓冲区中的数据均转为大写

返回: {string&} 当前对象的引用

◆ url_decode()

string& acl::string::url_decode	(	const char *	s,
		dbuf_pool *	dbuf = `NULL`
	)

将输入的用 url 编码的源数据解码并存入当前对象的缓冲区中

参数

s	{const char*} 经 url 编码的源数据
dbuf	{dbuf_pool*} 内存池对象，如果非空，则内部的动态内存在该对象上分配且当调用者在释放该对象时内部临时动态内存随之被释放，

返回: {string&} 当前对象的引用

◆ url_encode()

string& acl::string::url_encode	(	const char *	s,
		dbuf_pool *	dbuf = `NULL`
	)

将输入的源数据进行 url 编码并存入当前对象的缓冲区中

参数

s	{const char*} 源数据
dbuf	{dbuf_pool*} 内存池对象，如果非空，则内部的动态内存在该对象上分配且当调用者在释放该对象时内部临时动态内存随之被释放，否则使用 acl_mymalloc 分配并自动释放

返回: {string&} 当前对象的引用

◆ vformat()

string string& acl::string::vformat	(	const char *	fmt,
		va_list	ap
	)

带格式方式的添加数据（类似于 vsprintf 接口方式）

参数

fmt	{const char*} 格式字符串
ap	{va_list} 变参数据

返回: {string&} 当前对象的引用

◆ vformat_append()

string string& acl::string::vformat_append	(	const char *	fmt,
		va_list	ap
	)

带格式方式在当前对象的尾部添加数据

参数

fmt	{const char*} 格式字符串
ap	{va_list} 变参数据

返回: {string&} 当前对象的引用

◆ vstring()

ACL_VSTRING* acl::string::vstring ( void ) const

返回当前对象内部所用的 acl C 库中的 ACL_VSTRING 对象地址

返回: {ACL_VSTRING*} 返回值永远非空

该类的文档由以下文件生成:

include/acl_cpp/stdlib/string.hpp

Public 成员函数

静态 Public 成员函数

详细描述

构造及析构函数说明

◆ string() [1/7]

◆ string() [2/7]

◆ string() [3/7]

◆ string() [4/7]

◆ string() [5/7]

◆ string() [6/7]

◆ string() [7/7]

◆ ~string()

成员函数说明

◆ append() [1/4]

◆ append() [2/4]

◆ append() [3/4]

◆ append() [4/4]

◆ base64_decode() [1/3]

◆ base64_decode() [2/3]

◆ base64_decode() [3/3]

◆ base64_encode() [1/2]

◆ base64_encode() [2/2]

◆ basename()

◆ begin_with() [1/4]

◆ begin_with() [2/4]

◆ begin_with() [3/4]

◆ begin_with() [4/4]

◆ buf()

◆ buf_end()

◆ c_str()

◆ capacity()

◆ clear()

◆ compare() [1/4]

◆ compare() [2/4]

◆ compare() [3/4]

◆ compare() [4/4]

◆ copy() [1/2]

◆ copy() [2/2]

◆ dirname()

◆ empty()

◆ end_with() [1/4]

◆ end_with() [2/4]

◆ end_with() [3/4]

◆ end_with() [4/4]

◆ equal()

◆ find() [1/2]

◆ find() [2/2]

◆ find_blank_line()

◆ find_reset()

◆ format()

◆ format_append()

◆ get_bin()

◆ get_max()

◆ hex_decode()

◆ hex_encode()

◆ insert()

◆ left()

◆ length()

◆ lower()

◆ memmove() [1/2]

◆ memmove() [2/2]

◆ ncompare()

◆ operator const char *()

◆ operator const void *()

◆ operator!=() [1/3]

◆ operator!=() [2/3]

◆ operator!=() [3/3]

◆ operator+()

◆ operator+=() [1/15]

◆ operator+=() [2/15]

◆ operator+=() [3/15]

◆ operator+=() [4/15]

◆ operator+=() [5/15]

◆ operator+=() [6/15]

◆ operator+=() [7/15]

◆ operator+=() [8/15]

◆ operator+=() [9/15]

◆ operator+=() [10/15]

◆ operator+=() [11/15]

◆ operator+=() [12/15]