Glib学习（16）字符串函数 String Utility Functions

小咪咪 2022-05-31 14:07 327阅读 0赞

glib源码下载：http://ftp.gnome.org/pub/gnome/sources/glib/  
glib帮助文档：https://developer.gnome.org/glib/

本节主要讲述字符串函数，绝大部分函数在标准库中都能找到，或者简单几句话就能实现，这里只提供翻译部分，例程不提供了，需要的时候可以参考标准库函数实现。

gchar \*g\_strdup ()  
复制一个字符串。 如果str为NULL，则返回NULL。 不再需要时，返回的字符串应该用g\_free()来释放。  
参数  
str  
要复制的字符串。\[可空\]  
返回  
一个新分配的str的副本  
  
gchar \*g\_strndup ()  
复制字符串的前n个字节，返回一个新分配的缓冲区，长度为n + 1个字节，始终以nul结尾。 如果str小于n个字节，则缓冲区将被填充。 如果str为NULL，则返回NULL。 不再需要返回的值应该被释放。  
要从UTF-8编码的字符串复制多个字符，请改用g\_utf8\_strncpy()。  
参数  
str  
要复制的字符串  
n  
从str复制的最大字节数  
返回  
一个新分配的缓冲区，包含str的前n个字节，nul结尾  
  
gchar \*\*g\_strdupv ()  
复制以"/0"结尾的字符串数组。 该拷贝是一个深度拷贝; 需要首先释放每个字符串，然后释放数组，然后释放新数组。 g\_strfreev()为你做这件事。 如果输入NULL值，则g\_strdupv()仅返回NULL。  
参数  
str\_array  
以NULL结尾的字符串数组。\[可空\]  
返回  
一个新的以NULL结尾的字符串数组。\[可空\]  
  
gchar \*g\_strnfill ()  
创建一个长度为length字节的新字符串用fill\_char填充。 不再需要返回的字符串应该被释放。  
参数  
length  
新字符串的长度  
fill\_char  
用来填充字符串的字节  
返回  
一个新分配的字符串填充了fill\_char  
  
gchar \*g\_stpcpy ()  
将一个以'/0'结尾的字符串复制到dest缓冲区，包含尾部'/0'，并返回一个指向尾部'/0'字节的指针。 这对连接多个字符串非常有用，无需重复扫描。  
参数  
dest  
目标缓冲区。  
src  
源字符串。  
返回  
尾指针null字节的指针。  
  
gchar \*g\_strstr\_len ()  
搜索字符串haystack第一次出现的字符needle，将搜索的长度限制为haystack\_len。  
参数  
haystack  
一个字符串  
haystack\_len  
haystack 的最大长度。 请注意，如果haystack 是"/0"结尾，haystack是-1，这意味着它将搜索整个字符串。  
needle  
要搜索的字符串  
返回  
指向发现的指针，如果没有找到，则返回NULL。  
  
gchar \*g\_strrstr ()  
在字符串haystack中搜索字符串needle的最后一次出现。  
参数  
haystack  
一个nul结尾的字符串  
needle  
以null结尾的字符串进行搜索  
返回  
指向发现的指针，如果没有找到，则返回NULL。  
  
gchar \*g\_strrstr\_len ()  
在字符串haystack中搜索字符串needle的最后一次出现，将搜索长度限制为haystack\_len。  
参数  
haystack  
一个null结尾的字符串  
haystack\_len  
干草堆的最大长度  
needle  
以null结尾的字符串进行搜索  
返回  
指向发现的指针，如果没有找到，则返回NULL。  
  
gbooleang\_str\_has\_prefix ()  
查看字符串str是否以前缀开头。  
参数  
str  
一个"/0"结尾的字符串  
prefix  
以null结尾的前缀来寻找  
返回  
如果str以前缀开头则为TRUE，否则为FALSE。  
从：2.2  
  
gbooleang\_str\_has\_suffix ()  
查看字符串str是否以后缀结尾。  
参数  
str  
一个"/0"结尾的字符串  
suffix  
以null结尾的后缀来查找  
返回  
如果str以后缀结束则为TRUE，否则为FALSE。  
从：2.2  
  
intg\_strcmp0 ()  
像strcmp()比较str1和str2。 通过在非NULL字符串之前对其进行排序来优雅地处理NULL。 比较两个NULL指针返回0。  
参数  
str1  
一个C字符串或NULL。\[可空\]  
str2  
另一个C字符串或NULL。\[可空\]  
返回  
如果str1是<，==或>str2，则为小于，等于或大于零的整数。  
从：2.16  
  
gchar \*g\_str\_to\_ascii ()  
将str转换为纯ASCII。  
为了获得最好的结果，str应该是组成规范化的形式。  
这个函数执行一组相当好的字符替换。 完成的特定替换集可能会根据版本甚至运行时环境而改变。  
如果str的源语言是已知的，则可以通过将它作为from\_locale传递来提高翻译的准确性。 它应该是一个有效的POSIX语言环境字符串(形式为“language\_territory \[modifier\]”)。  
如果from\_locale为NULL，则使用当前的语言环境。  
如果您想为特定语言环境进行翻译，并且希望独立于当前语言环境进行翻译，请为from\_locale指定“C”。  
参数  
str  
一个字符串，用UTF-8  
from\_locale  
源地区，如果知道的话。\[可空\]  
返回  
一个纯ASCII的字符串  
从：2.40  
  
gchar \*\*g\_str\_tokenize\_and\_fold ()  
标记字符串并在每个标记上执行折叠。  
标记是源字符串中非空字母数字字符序列，由非字母数字字符分隔。 用于此目的的“字母数字”字符是与g\_unichar\_isalnum()或g\_unichar\_ismark()相匹配的字符。  
然后每个标记(Unicode)标准化和大小写折叠。 如果ascii\_alternates不是NULL，并且某些返回的标记包含非ASCII字符，则将生成ASCII替代标记。  
生成的ASCII替代品的数量和方法是未指定的，但是如果源字符串的语言是已知的，则translit\_locale(如果指定)可以改善音译。  
参数  
string  
一个字符串  
translit\_locale  
语言代码(如“de”或“en\_GB”)来自哪个字符串。\[可空\]  
ascii\_alternates  
ASCII交替的返回位置。\[out\] \[transfer full\] \[array zero-terminated = 1\]  
返回  
折叠的令牌。\[传输完整\] \[数组零终止= 1\]  
从：2.40  
  
gbooleang\_str\_match\_string ()  
检查针对search\_term进行的搜索是否应与potential\_hit匹配。  
该函数在search\_term和potential\_hit上调用g\_str\_tokenize\_and\_fold()。对于search\_term，ASCII交替不会被采用，但会根据accept\_alternates的值而被用于potential\_hit。  
当search\_term中的每个折叠标记都是来自potential\_hit的折叠标记的前缀时，就会发生一次命中。  
根据执行搜索的方式，对语料库中的每个字符串调用g\_str\_tokenize\_and\_fold()通常会更快，并在返回的折叠令牌上构建索引，然后在搜索项上调用g\_str\_tokenize\_and\_fold()，然后执行查找指数。  
作为一些例子，寻找'fred'将匹配潜在的命中'Smith, Fred'，还有'Frédéric'。搜索'Fréd'会匹配'Frédéric'，但不匹配'Frederic'(由于口音匹配的单向性)。搜索'fo'将匹配'Foo'和'Bar Foo Baz'，但不匹配'SFO'(因为没有词作为前缀)。  
参数  
search\_term  
来自用户的搜索词  
potential\_hit  
可能是一个打击的文字  
accept\_alternates  
为真以接受ASCII交替  
返回  
如果potential\_hit是命中，则为TRUE  
从：2.40  
  
gsizeg\_strlcpy ()  
可移植包装器，它在拥有它的系统上调用strlcpy()，否则模拟strlcpy()。 将src复制到dest; dest保证被终止; src必须以nul结尾; dest\_size是缓冲区大小，而不是要复制的字节数。  
至多dest\_size - 1个字符将被复制。 总是终止(除非dest\_size是0)。 此功能不分配内存。 与strncpy()不同，这个函数不会填充dest(所以它通常更快)。 它返回尝试结果strlen(src)的大小，所以如果retval> = dest\_size，则发生截断。  
警告：strlcpy()被认为比strcpy()或者strncpy()更安全，但如果你真的想避免耦合，g\_strdup()是一个更好的主意。  
参数  
dest  
目标缓冲区  
src  
源缓冲区  
dest\_size  
dest的长度，以字节为单位  
返回  
src的长度  
  
gsizeg\_strlcat ()  
可移植包装器在拥有它的系统上调用strlcat()，并以其他方式模拟它。将nul-terminated src字符串追加到dest，保证dest不会终止。 dest的总大小不会超过dest\_size。  
至多dest\_size - 1个字符将被复制。与strncat()不同，dest\_size是dest的全部大小，而不是剩下的空间。此功能不分配内存。它总是终止的(除非dest\_size == 0，或者在dest的dest\_size字符中没有nul字符才开始)。  
警告：这应该是strcat()或strncat()的更安全的替代方法，但是为了真正的安全性，g\_strconcat()很难搞定。  
参数  
dest  
目标缓冲区，已经包含一个nul结尾的字符串  
src  
源缓冲区  
dest\_size  
dest缓冲区的长度(以字节为单位)  
返回  
尝试结果的大小，即MIN(dest\_size，strlen(original dest))+ strlen(src)，所以如果retval> = dest\_size，则发生截断。  
  
gchar \*g\_strdup\_printf ()  
与标准的C sprintf()函数类似，但更安全，因为它计算所需的最大空间并分配内存来保存结果。 不再需要时，返回的字符串应该用g\_free()来释放。  
参数  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
...  
要插入格式字符串的参数  
返回  
保存结果的新分配的字符串  
  
gchar \*g\_strdup\_vprintf ()  
与标准的C vsprintf()函数类似，但更安全，因为它计算所需的最大空间并分配内存来保存结果。 不再需要时，返回的字符串应该用g\_free()来释放。  
另请参阅g\_vasprintf()，它提供了相同的功能，但还会返回分配的字符串的长度。  
参数  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
args  
要插入格式字符串的参数列表  
返回  
保存结果的新分配的字符串  
  
gintg\_printf ()  
标准printf()函数的实现支持位置参数，如单一Unix规范中所指定的那样。  
与标准printf()一样，这不会自动将追尾的换行符添加到消息中，因此通常格式应该以其自己的换行符结尾。  
必须明确包含glib / gprintf.h才能使用此函数。  
参数  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
...  
要在输出中插入的参数。  
返回  
打印的字节数。  
从：2.2  
  
gintg\_vprintf ()  
一个支持位置参数的标准vprintf()函数的实现，如单一Unix规范中指定的那样。  
必须明确包含glib / gprintf.h才能使用此函数。  
参数  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
args  
要在输出中插入的参数列表。  
返回  
打印的字节数。  
由于：2.2  
  
gintg\_fprintf ()  
一个支持位置参数的标准fprintf()函数的实现，如Single Unix Specification中所指定的。  
必须明确包含glib / gprintf.h才能使用此函数。  
参数  
file  
要写入的流。\[不可空\]  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
...  
要在输出中插入的参数。  
返回  
打印的字节数。  
由于：2.2  
  
gintg\_vfprintf ()  
一个支持位置参数的标准fprintf()函数的实现，如Single Unix Specification中所指定的。  
必须明确包含glib / gprintf.h才能使用此函数。  
参数  
file  
要写入的流。\[不可空\]  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
args  
要在输出中插入的参数列表。  
返回  
打印的字节数。  
由于：2.2  
  
gintg\_sprintf ()  
按照Unix Unix规范中的规定，支持位置参数的标准sprintf()函数的实现。  
请注意，通常使用g\_snprintf()更好，以避免缓冲区溢出的风险。  
必须明确包含glib / gprintf.h才能使用此函数。  
另请参阅g\_strdup\_printf()。  
参数  
string  
指向内存缓冲区的指针，以包含结果字符串。 由调用者确定分配的缓冲区足够大以容纳格式化的结果  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
...  
要在输出中插入的参数。  
返回  
打印的字节数。  
由于：2.2  
  
gintg\_vsprintf ()  
一个支持位置参数的标准vsprintf()函数的实现，如单一Unix规范中指定的那样。  
必须明确包含glib / gprintf.h才能使用此函数。  
参数  
string  
保存输出的缓冲区。  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
args  
要在输出中插入的参数列表。  
返回  
打印的字节数。  
由于：2.2  
  
gintg\_snprintf ()  
标准sprintf()函数的更安全形式。输出保证不超过n个字符(包括终止nul字符)，所以很容易确保不会发生缓冲区溢出。  
另请参阅g\_strdup\_printf()。  
在1.2.3之前的GLib版本中，如果输出被截断，则此函数可能返回-1，并且截断的字符串可能不以nul结尾。在1.3.12之前的版本中，这个函数返回输出字符串的长度。  
g\_snprintf()的返回值与ISO C99中标准化的snprintf()函数一致。请注意，这与传统的snprintf()不同，后者返回输出字符串的长度。  
格式化字符串可能包含位置参数，如单一Unix规范中所指定的。  
参数  
string  
保存输出的缓冲区。  
n  
要生成的最大字节数(包括终止的nul字符)。  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
...  
要在输出中插入的参数。  
返回  
如果缓冲区足够大，将会产生的字节数。  
  
gintg\_vsnprintf ()  
标准的vsprintf()函数的一个更安全的形式。输出保证不超过n个字符(包括终止nul字符)，所以很容易确保不会发生缓冲区溢出。  
另请参阅g\_strdup\_vprintf()。  
在1.2.3之前的GLib版本中，如果输出被截断，则此函数可能返回-1，并且截断的字符串可能不以nul结尾。在1.3.12之前的版本中，这个函数返回输出字符串的长度。  
g\_vsnprintf()的返回值符合ISO C99中标准化的vsnprintf()函数。请注意，这与传统的vsnprintf()不同，后者返回输出字符串的长度。  
格式化字符串可能包含位置参数，如单一Unix规范中所指定的。  
参数  
string  
保存输出的缓冲区。  
n  
要生成的最大字节数(包括终止的nul字符)。  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱\] \[string-precision\]  
args  
要在输出中插入的参数列表。  
返回  
如果缓冲区足够大，将会产生的字节数。  
  
gintg\_vasprintf ()  
GNU vasprintf()函数的实现支持位置参数，如单一Unix规范中所述。 这个函数类似于g\_vsprintf()，除了它分配一个字符串来保存输出，而不是把输出放在你预先分配的缓冲区中。  
必须明确包含glib / gprintf.h才能使用此函数。  
参数  
string  
新分配的字符串的返回位置。  
format  
一个标准的printf()格式字符串，但通知字符串精度陷阱  
args  
要在输出中插入的参数列表。  
返回  
打印的字节数。  
由于：2.4  
  
gsizeg\_printf\_string\_upper\_bound ()  
计算存储sprintf()函数输出所需的最大空间。  
参数  
format  
格式字符串。 请参阅printf()文档  
args  
要插入到格式字符串中的参数  
返回  
存储格式化字符串所需的最大空间  
  
gbooleang\_str\_is\_ascii ()  
确定一个字符串是纯粹的ASCII。 如果字符串不包含高位设置的字符，则该字符串为纯ASCII。  
参数  
str  
一个字符串  
返回  
如果str是ASCII，则为TRUE  
由于：2.40  
  
gbooleang\_ascii\_isalnum ()  
确定一个字符是否是字母数字。  
与标准C库isalnum()函数不同，它只识别标准ASCII字母并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII字母数字字符，则为TRUE  
  
gbooleang\_ascii\_isalpha ()  
确定一个字符是否是字母(即一个字母)。  
与标准C库isalpha()函数不同，它只识别标准ASCII字母并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII字母字符，则为TRUE  
  
gbooleang\_ascii\_iscntrl ()  
确定一个角色是否是一个控制角色。  
与标准C库iscntrl()函数不同，它只识别标准的ASCII控制字符并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII控制字符，则为TRUE。  
  
gbooleang\_ascii\_isdigit ()  
确定一个字符是否是数字(0-9)。  
与标准C库isdigit()函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
C  
任何角色  
返回  
如果c是ASCII数字，则为TRUE。  
  
gbooleang\_ascii\_isgraph ()  
确定一个字符是否是数字(0-9)。  
与标准C库isdigit()函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII数字，则为TRUE。  
  
gbooleang\_ascii\_islower ()  
确定一个字符是否是一个ASCII小写字母。  
与标准的C库islower()函数不同，它只识别标准的ASCII字母并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，这需要一个char而不是int，所以不要在EOF上调用它，但是在传递可能的非ASCII字符之前不需要担心转换为guchar  
参数  
c  
任何角色  
返回  
如果c是一个ASCII小写字母，则为TRUE  
  
gbooleang\_ascii\_isprint ()  
确定一个字符是否是打印字符。  
与标准C库isprint()函数不同，它仅识别标准ASCII字符并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII打印字符，则为TRUE。  
  
gbooleang\_ascii\_ispunct ()  
确定一个字符是否是标点符号。  
与标准的C库ispunct()函数不同，它只识别标准的ASCII字母并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII标点符号，则为TRUE。  
  
gbooleang\_ascii\_isspace ()  
确定角色是否为空白字符。  
与标准的C库isspace()函数不同，它只识别标准的ASCII空白并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，它需要一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII空白字符，则为TRUE  
  
gbooleang\_ascii\_isupper ()  
确定一个字符是否是ASCII大写字母。  
与标准C库isupper()函数不同，它只识别标准的ASCII字母并忽略语言环境，对所有非ASCII字符返回FALSE。 另外，与标准库函数不同，这需要一个char而不是int，所以不要在EOF上调用它，但是在传递可能的非ASCII字符之前不需要担心转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII大写字母，则为TRUE  
  
gbooleang\_ascii\_isxdigit ()  
确定一个字符是否是十六进制数字字符。  
与标准的C库isxdigit()函数不同，它接受一个char而不是int，所以不要在EOF上调用它，但在传递可能的非ASCII字符之前不需要强制转换为guchar。  
参数  
c  
任何角色  
返回  
如果c是ASCII十六进制数字字符，则为TRUE。  
  
gintg\_ascii\_digit\_value ()  
将字符的数字值确定为十进制数字。 与g\_unichar\_digit\_value()不同，因为它需要一个字符，所以如果字符被签名，就不用担心签名扩展。  
参数  
c  
一个ASCII字符  
返回  
如果c是十进制数字(根据g\_ascii\_isdigit())，则为其数字值。 否则，-1。  
  
gintg\_ascii\_xdigit\_value ()  
将字符的数字值确定为十六进制数字。 与g\_unichar\_xdigit\_value()不同，因为它需要一个字符，所以如果字符被签名，就不用担心签名扩展。  
参数  
c  
一个ASCII字符。  
返回  
如果c是十六进制数字(根据g\_ascii\_isxdigit())，则为其数字值。 否则，-1。  
  
gintg\_ascii\_strcasecmp ()  
比较两个字符串，忽略ASCII字符的情况。  
与BSD strcasecmp()函数不同，它只识别标准的ASCII字母并忽略语言环境，将所有非ASCII字节视为不是字母。  
这个函数只能用于已知的编码字符串，其中对应于ASCII字母的字节总是表示自己。 这包括UTF-8和ISO-8859- \*字符集，但不包括像Windows Codepage 932这样的双字节编码，其中双字节字符的尾部字节包括所有ASCII字母。 如果使用此函数比较两个CP932字符串，则会得到错误匹配。  
s1和s2都必须是非空的。  
参数  
s1  
字符串与s2进行比较  
s2  
字符串与s1进行比较  
返回  
如果字符串匹配，则为0;如果s1 <s2，则为负值;如果s1> s2，则为正值。  
  
gintg\_ascii\_strncasecmp ()  
比较s1和s2，忽略每个字符串中第一个n后面的ASCII字符和任何字符的情况。  
与BSD strcasecmp()函数不同，它只识别标准的ASCII字母并忽略语言环境，将所有非ASCII字符视为不是字母。  
与g\_ascii\_strcasecmp()中相同的警告适用：仅在已知为编码的字符串中使用此函数，其中对应于ASCII字母的字节总是表示它们自己。  
参数  
s1  
字符串与s2进行比较  
s2  
字符串与s1进行比较  
n  
要比较的字符数  
返回  
如果字符串匹配，则为0;如果s1 <s2，则为负值;如果s1> s2，则为正值。  
  
gchar \*g\_ascii\_strup ()  
将所有小写ASCII字母转换为大写ASCII字母。  
参数  
str  
一个字符串  
len  
以字节为单位的str的长度，或者如果str以null结尾，则为-1  
返回  
一个新分配的字符串，str中的所有小写字符转换为大写，语义与g\_ascii\_toupper()完全匹配。 (请注意，这与旧的g\_strup()不同，后者修改了字符串。)  
  
gchar \*g\_ascii\_strdown ()  
将所有大写ASCII字母转换为小写ASCII字母。  
参数  
str  
一个字符串  
len  
以字节为单位的str的长度，或者如果str以nul结尾，则为-1  
返回  
一个新分配的字符串，str中的所有大写字符都转换为小写字母，其语义与g\_ascii\_tolower()完全匹配。 (请注意，这与旧的g\_strdown()不同，它修改了字符串)。  
  
gcharg\_ascii\_tolower ()  
将一个字符转换为ASCII小写。  
与标准C库tolower()函数不同，它只识别标准ASCII字母并忽略语言环境，即使它们是特定字符集中的小写字母，也会返回所有非ASCII字符。 另外，与标准库函数不同，这需要并返回一个char，而不是int，所以不要在EOF上调用它，但不必担心在传递可能的非ASCII字符之前转换为guchar。  
参数  
c  
任何角色  
返回  
将c转换为小写的结果。 如果c不是ASCII大写字母，则c不变。  
  
gcharg\_ascii\_toupper ()  
将一个字符转换为ASCII大写。  
与标准C库toupper()函数不同，它只识别标准ASCII字母并忽略语言环境，即使它们是特定字符集中的大写字母，也将返回所有非ASCII字符。 另外，与标准库函数不同，这需要并返回一个char，而不是int，所以不要在EOF上调用它，但不必担心在传递可能的非ASCII字符之前转换为guchar。  
参数  
c  
任何角色  
返回  
将c转换为大写的结果。 如果c不是ASCII小写字母，则c不变。  
  
GString \*g\_string\_ascii\_up ()  
将所有小写ASCII字母转换为大写ASCII字母。  
参数  
string  
一个GString  
返回  
传入的字符串指针，所有的小写字符转换为大写，语义与g\_ascii\_toupper()完全匹配。\[转移无\]  
  
GString \*g\_string\_ascii\_down ()  
将所有大写ASCII字母转换为小写ASCII字母。  
参数  
string  
一个GString  
返回  
传入的字符串指针，所有大写字符转换为小写字母，语义与g\_ascii\_tolower()完全匹配。\[转移无\]  
  
gchar \*g\_strreverse ()  
反转字符串中的所有字节。 例如，g\_strreverse(“abcdef”)将导致“fedcba”。  
请注意，g\_strreverse()在包含多字节字符的UTF-8字符串上不起作用。 为此，使用g\_utf8\_strreverse()。  
参数  
string  
要反转的字符串  
返回  
与字符串相同的指针传入  
  
gint64g\_ascii\_strtoll ()  
将字符串转换为gint64值。该函数的行为与标准strtoll()函数在C语言环境中的行为相同。它没有实际改变当前的语言环境，因为这不会是线程安全的。  
这个函数通常用于读取配置文件或其他应该独立于语言环境的非用户输入。要处理来自用户的输入，通常应使用区域敏感系统strtoll()函数。  
如果正确的值会导致溢出，则返回G\_MAXINT64或G\_MININT64，ERANGE存储在errno中。如果基数在有效范围之外，则返回零，并将EINVAL存储在errno中。如果字符串转换失败，则返回零，endptr返回nptr(如果endptr不是NULL)。  
参数  
nptr  
要转换为数字值的字符串。  
endptr  
如果非NULL，则返回转换中使用的最后一个字符后面的字符。\[输出\] \[传输无\] \[可选\]  
base  
用于转换，2..36或0  
返回  
gint64值或错误为零。  
从：2.12  
  
guint64g\_ascii\_strtoull ()  
将字符串转换为guint64值。该函数的行为与标准的strtoull()函数在C语言环境中的行为相同。它没有实际改变当前的语言环境，因为这不会是线程安全的。  
这个函数通常用于读取配置文件或其他应该独立于语言环境的非用户输入。要处理来自用户的输入，通常应使用区域敏感系统strtoull()函数。  
如果正确的值会导致溢出，则返回G\_MAXUINT64，并将ERANGE存储在errno中。如果基数在有效范围之外，则返回零，并将EINVAL存储在errno中。如果字符串转换失败，则返回零，endptr返回nptr(如果endptr不是NULL)。  
参数  
nptr  
要转换为数字值的字符串。  
endptr  
如果非NULL，则返回转换中使用的最后一个字符后面的字符。\[输出\] \[传输无\] \[可选\]  
base  
用于转换，2..36或0  
返回  
guint64值或错误为零。  
由于：2.2  
  
gdoubleg\_ascii\_strtod ()  
将字符串转换为gdouble值。  
该函数的行为与标准strtod()函数在C语言环境中的行为相同。它没有实际改变当前的语言环境，因为这不会是线程安全的。实现的一个限制是这个函数仍然会接受无穷大和NAN的本地化版本。  
这个函数通常用于读取配置文件或其他应该独立于语言环境的非用户输入。要处理来自用户的输入，通常应使用区域敏感系统strtod()函数。  
要以不区分语言的方式将gdouble转换为字符串，请使用g\_ascii\_dtostr()。  
如果正确的值会导致溢出，则返回加号或减号HUGE\_VAL(根据值的符号)，并将ERANGE存储在errno中。如果正确的值会导致下溢，则返回零并将ERANGE存储在errno中。  
该函数在调用strtod()之前重置errno，以便可以可靠地检测上溢和下溢。  
参数  
nptr  
要转换为数字值的字符串。  
endptr  
如果非NULL，则返回转换中使用的最后一个字符后面的字符。\[输出\] \[传输无\] \[可选\]  
返回  
gdouble的价值。  
  
gchar \*g\_ascii\_dtostr ()  
使用'.'将gdouble转换为字符串。 作为小数点。  
这个函数产生足够的精度，使用g\_ascii\_strtod()将字符串转换回来(在IEEE兼容的64位双打的机器上)。 保证结果字符串的大小决不会大于G\_ASCII\_DTOSTR\_BUF\_SIZE字节，包括总是添加的"/0"字符。  
参数  
buffer  
放置结果字符串的缓冲区  
buf\_len  
缓冲区的长度。  
d  
gdouble转换  
返回  
指向带有转换字符串的缓冲区的指针。  
  
gchar \*g\_ascii\_formatd ()  
使用'.'将gdouble转换为字符串。 作为小数点。 使用printf()风格的格式字符串格式化传递的数字。 允许的转换说明符是'e'，'E'，'f'，'F'，'g'和'G'。  
返回的缓冲区保证以"/0"结尾。  
如果您只是想要将该值序列化为字符串，请使用g\_ascii\_dtostr()。  
参数  
缓冲  
放置结果字符串的缓冲区  
buf\_len  
缓冲区的长度。  
格式  
用于代码转换的printf()样式格式。  
d  
gdouble转换  
返回  
指向带有转换字符串的缓冲区的指针。  
  
gdoubleg\_strtod ()  
将字符串转换为gdouble值。 它调用标准的strtod()函数来处理转换，但是如果字符串没有完全转换，它将再次使用g\_ascii\_strtod()尝试转换，并返回最佳匹配。  
这个功能应该很少使用。 阅读不适合人类消费的数字时的正常情况是使用g\_ascii\_strtod()。 只有当你知道你必须同时使用区域设置格式和C格式的数字。 确保不传递逗号分隔的值列表等字符串，因为逗号可能会在某些语言环境中被解释为小数点，从而导致意外的结果。  
参数  
nptr  
要转换为数值的字符串。  
endptr  
如果非NULL，则返回转换中使用的最后一个字符之后的字符。\[输出\] \[传送无\] \[可选\]  
返回  
gdouble的价值。  
  
gbooleang\_ascii\_string\_to\_signed ()  
将字符串转换为带符号数字的便利函数。  
这个函数假设str只包含一个给定的基数，这个基数是在min和max限制的容限范围内。如果这是真的，那么转换后的数字将存储在out\_num中。一个空字符串不是有效的输入。带有前导或尾随空白的字符串也是无效的输入。  
基数可以在2到36之间(含)。十六进制数字不能以“0x”或“0X”作为前缀。对于八进制数不存在这样的问题，因为它们通常以零为前缀，这不会改变解析的数字的值。  
解析失败会导致G\_NUMBER\_PARSER\_ERROR域发生错误。如果输入无效，则错误代码将为G\_NUMBER\_PARSER\_ERROR\_INVALID。如果分析的数字超出范围 - G\_NUMBER\_PARSER\_ERROR\_OUT\_OF\_BOUNDS。  
如果您有更复杂的需求，请参阅g\_ascii\_strtoll()，例如解析以数字开头的字符串，然后使用其他字符。  
参数  
str  
一个字符串  
base  
分析数字的基础  
min  
下限(含)  
max  
上限(含)  
out\_num  
一个数字的返回位置。\[OUT\] \[可选\]  
error  
GError的返回位置  
返回  
如果str是一个数字，则为TRUE，否则为FALSE。  
由于：2.54  
  
gbooleang\_ascii\_string\_to\_unsigned ()  
将字符串转换为无符号数的方便函数。  
这个函数假设str只包含一个给定的基数，这个基数是在min和max限制的容限范围内。如果这是真的，那么转换后的数字将存储在out\_num中。一个空字符串不是有效的输入。带有前导或尾随空白的字符串也是无效的输入。  
基数可以在2到36之间(含)。十六进制数字不能以“0x”或“0X”作为前缀。对于八进制数不存在这样的问题，因为它们通常以零为前缀，这不会改变解析的数字的值。  
解析失败会导致G\_NUMBER\_PARSER\_ERROR域发生错误。如果输入无效，则错误代码将为G\_NUMBER\_PARSER\_ERROR\_INVALID。如果分析的数字超出范围 - G\_NUMBER\_PARSER\_ERROR\_OUT\_OF\_BOUNDS。  
如果您有更复杂的需求，请参阅g\_ascii\_strtoull()，例如解析以数字开头的字符串，但其后有其他字符。  
参数  
str  
一个字符串  
base  
分析数字的基础  
min  
下限(含)  
max  
上限(含)  
out\_num  
一个数字的返回位置。\[OUT\] \[可选\]  
error  
GError的返回位置  
返回  
如果str是一个数字，则为TRUE，否则为FALSE。  
由于：2.54  
  
gchar \*g\_strchug ()  
通过向前移动其余字符，从字符串中删除前导空格。  
这个函数不分配或重新分配任何内存; 它修改字符串到位。 因此，它不能用于静态分配的字符串。  
返回字符串指针以允许嵌套函数。  
另请参阅g\_strchomp()和g\_strstrip()。  
参数  
string  
一个字符串，用于从中删除前导空格  
返回  
串  
  
gchar \*g\_strchomp ()  
从字符串中删除尾随的空格。  
这个函数不分配或重新分配任何内存; 它修改字符串到位。 因此，它不能用于静态分配的字符串。  
返回字符串指针以允许嵌套函数。  
另请参阅g\_strchug()和g\_strstrip()。  
参数  
string  
一个字符串，用于删除尾部的空白  
返回  
串  
  
\#defineg\_strstrip()  
从字符串中删除前导和尾随空白。 请参阅g\_strchomp()和g\_strchug()。  
参数  
string  
一个字符串，用于从中删除前导和后缀的空白  
返回  
串  
  
gchar \*g\_strdelimit ()  
将字符串中的任何分隔符转换为new\_delimiter。 在分隔符中找到的字符串中的任何字符都会更改为new\_delimiter字符。 修改字符串，并返回字符串本身，而不是副本。 返回值是允许嵌套的  
g\_ascii\_strup(g\_strdelimit(str，“abc”，'?'))  
参数  
string  
要转换的字符串  
delimiters  
包含当前分隔符的字符串，或者使用NULL来使用G\_STR\_DELIMITERS中定义的标准分隔符。\[可空\]  
new\_delimiter  
新的分隔符  
返回  
串  
  
gchar \*g\_strescape ()  
在字符串源中通过插入'\\ f'，'\\ n'，'\\ r'，'\\ t'，'\\ v'，'\\'和' '在0x01-0x1F范围内的所有字符(空格以下的所有字符)和0x7F-0xFF范围内的所有字符(所有非ASCII字符)被替换为'\\'，然后是八进制表示。 没有逃脱。  
g\_strcompress()进行反向转换。  
参数  
source  
一个字符串来逃避  
exceptions  
一串字符不能在源代码中转义。\[可空\]  
返回  
一个新分配的特定字符的源文件被转义。 往上看。  
  
gchar \*g\_strcompress ()  
将所有转义字符替换为相同的一个字节。  
该函数执行g\_strescape()的反向转换。  
参数  
source  
要压缩的字符串  
返回  
一个新分配的所有转义字符的副本压缩  
  
gchar \*g\_strcanon ()  
对于字符串中的每个字符，如果该字符不在valid\_chars中，则用替代字符替换该字符。 修改字符串，返回字符串本身，而不是副本。 返回值是允许嵌套的  
g\_ascii\_strup(g\_strcanon(str，“abc”，'？'))  
参数  
string  
一个以nul结尾的字节数组  
valid\_chars  
字符串中允许的字节  
substitutor  
替换字符为不允许的字节  
返回  
串  
  
gchar \*\*g\_strsplit ()  
使用给定的分隔符将一个字符串分割成max\_tokens块的最大值。如果达到了max\_tokens，则字符串的其余部分被追加到最后一个标记。  
例如，g\_strsplit(“：a：bc :: d：”，“：”，-1)的结果是包含六个字符串“”，“a”，“bc”，“” ，“d”和“”。  
作为特殊情况，分割空字符串“”“的结果是空向量，而不是包含单个字符串的向量。这种特殊情况的原因是能够表示一个空向量通常比一致处理空元素更有用。如果您确实需要表示空元素，则需要在调用g\_strsplit()之前检查空字符串。  
参数  
string  
一个要分割的字符串  
delimiter  
一个字符串，指定分割字符串的位置。分隔符不包含在任何结果字符串中，除非达到max\_tokens。  
max\_tokens  
将字符串拆分成的最大数量。如果小于1，则字符串被完全分割。  
返回  
一个新分配的以NULL结尾的字符串数组。使用g\_strfreev()释放它。  
  
gchar \*\*g\_strsplit\_set ()  
将字符串拆分成许多不包含分隔符中任何字符的标记。令牌是(可能为空)最长的字符串，它不包含分隔符中的任何字符。如果达到了max\_tokens，余数将被追加到最后一个标记。  
例如，g\_strsplit\_set(“abc：def / ghi”，“：/”，-1)的结果是包含三个字符串“abc”，“def”和“ghi”的以NULL结尾的向量。  
g\_strsplit\_set(“：def / ghi：”，“：/”，-1)的结果是包含四个字符串“”，“def”，“ghi”和“”的以NULL结尾的向量。  
作为特殊情况，分割空字符串“”“的结果是空向量，而不是包含单个字符串的向量。这种特殊情况的原因是能够表示一个空向量通常比一致处理空元素更有用。如果您确实需要表示空元素，则需要在调用g\_strsplit\_set()之前检查空字符串。  
请注意，此函数对字节而不是字符起作用，因此不能用于为除ASCII字符之外的其他字符分隔UTF-8字符串。  
参数  
string  
要标记的字符串  
delimiters  
包含用于分割字符串的字节的以nul结尾的字符串。  
max\_tokens  
将字符串拆分为的最大令牌数。如果小于1，则字符串被完全分割  
返回  
一个新分配的以NULL结尾的字符串数组。使用g\_strfreev()释放它。  
由于：2.4  
  
voidg\_strfreev ()  
释放以NULL结尾的字符串数组以及它包含的每个字符串。  
如果str\_array是NULL，这个函数只是返回。  
参数  
str\_array  
以NULL结尾的字符串数组释放。\[可空\]  
  
gchar \*g\_strconcat ()  
将所有给定的字符串连接成一个长字符串。 不再需要时，返回的字符串应该用g\_free()来释放。  
可变参数列表必须以NULL结尾。 如果你忘记NULL，g\_strconcat()将开始将随机内存垃圾附加到你的字符串。  
请注意，这个函数通常不是正确的函数，因为正确的翻译通常需要重新排序。  
参数  
string1  
要添加的第一个字符串，它不能为NULL  
...  
以字符串结尾的以NULL结尾的字符串列表  
返回  
包含所有字符串参数的新分配的字符串  
  
gchar \*g\_strjoin ()  
将多个字符串连接在一起形成一个长字符串，并在每个字符串之间插入可选的分隔符。 返回的字符串应该使用g\_free()来释放。  
参数  
separator  
在每个字符串之间插入的字符串，或NULL。\[可空\]  
...  
以NULL结尾的字符串列表  
返回  
一个新分配的字符串，包含所有连接在一起的字符串，以及它们之间的分隔符  
  
gchar \*g\_strjoinv ()  
将多个字符串连接在一起形成一个长字符串，并在每个字符串之间插入可选的分隔符。 返回的字符串应该使用g\_free()来释放。  
如果str\_array没有项目，返回值将是一个空字符串。 如果str\_array包含单个项目，分隔符将不会出现在结果字符串中。  
参数  
separator  
在每个字符串之间插入的字符串，或NULL。\[可空\]  
str\_array  
以NULL结尾的字符串数组加入  
返回  
一个新分配的字符串，包含所有连接在一起的字符串，以及它们之间的分隔符  
  
guintg\_strv\_length ()  
返回给定的以NULL结尾的字符串数组str\_array的长度。  
参数  
str\_array  
以NULL结尾的字符串数组  
返回  
str\_array的长度。  
由于：2.6  
  
gbooleang\_strv\_contains ()  
检查strv是否包含str。 strv不能为NULL。  
参数  
strv  
以NULL结尾的字符串数组  
str  
一个字符串  
返回  
根据g\_str\_equal()，如果str是strv的元素，则为TRUE。  
从：2.44  
  
const gchar \*g\_strerror ()  
返回对应于给定错误代码的字符串，例如 “没有这样的过程”。 与strerror()不同，它总是以UTF-8编码返回一个字符串，并且指针保证在进程的整个生命周期内保持有效。  
请注意，该字符串可能会根据当前的语言环境进行翻译。  
errno的值不会被这个函数改变。 但是，它可能会被中间函数调用改变，所以你应该在调用返回时立即保存它的值：  
int saved\_errno;  
ret = read(blah);  
saved\_errno = errno;  
g\_strerror(saved\_errno);  
参数  
errnum  
系统错误号。 请参阅标准的C errno文档  
返回  
描述错误代码的UTF-8字符串。 如果错误代码是未知的，则返回一个字符串，如“未知错误(<code>)”。  
  
const gchar \*g\_strsignal ()  
返回描述给定信号的字符串，例如 “分段故障”。 您应该优先使用此函数strsignal()，因为它返回UTF-8编码的字符串，并且不是所有的平台都支持strsignal()函数。  
参数  
signum  
信号号码。 请参阅信号文档  
返回  
描述信号的UTF-8字符串。 如果信号未知，则返回“未知信号(<signum>)”。  
  
类型和值  
  
\#defineG\_ASCII\_DTOSTR\_BUF\_SIZE  
缓冲区的大小可以传入g\_ascii\_dtostr()。 对于具有64位IEEE兼容双打的系统的所有输出保证足够。  
典型的用法如下所示：  
char buf \[G\_ASCII\_DTOSTR\_BUF\_SIZE\];  
fprintf(out，“value =％s \\ n”，g\_ascii\_dtostr(buf，sizeof(buf)，value));  
  
enumGNumberParserError  
由将字符串转换为数字的函数返回的错误代码。  
Members  
G\_NUMBER\_PARSER\_ERROR\_INVALID  
字符串不是一个有效的数字。  
G\_NUMBER\_PARSER\_ERROR\_OUT\_OF\_BOUNDS  
字符串是一个数字，但超出了界限。  
由于：2.54  
  
\#defineG\_NUMBER\_PARSER\_ERROR  
通过将字符串转换为数字的函数返回的错误域。  
由于：2.54  
  
\#defineG\_STR\_DELIMITERS  
g\_strdelimit()中使用的标准分隔符。  
  
typedefGStrv  
gchar \*\*的typedef别名。 当与g\_auto()一起使用时，这是非常有用的。