Glib学习（17） Key-value文件解析器 Key-value file parser

布满荆棘的人生 2022-05-30 10:55 286阅读 0赞

glib源码下载：http://ftp.gnome.org/pub/gnome/sources/glib/

glib帮助文档：https://developer.gnome.org/glib/

本节主要讲解Key-value文件解析器，可以轻松的帮我们实现配置文件的解析，类似于.ini文件的解析。

Includes  
\#include <glib.h>  
\#include <glib/gprintf.h>  
  
描述  
GKeyFile允许您解析，编辑或创建包含键值对的文件，我们称之为“key files”，因为缺少更好的名称。 一些freedesktop.org规范现在使用key files，例如Desktop Entry Specification和Icon Theme Specification。  
key files的语法在Desktop Entry Specification中有详细描述，这里是一个快速总结：key files由多组键值对组成，其中散布着注释。

# this is just an example
    # there can be comments before the first group
    [First Group]
    Name=Key File Example\tthis value shows\nescaping
    # localized strings are stored in multiple key-value pairs
    Welcome=Hello
    Welcome[de]=Hallo
    Welcome[fr_FR]=Bonjour
    Welcome[it]=Ciao
    Welcome[be@latin]=Hello
    [Another Group]
    Numbers=2;20;-200;0
    Booleans=true;false;true;true

以'＃'开头的行和空行被视为注释。  
组由包含在'\['和'\]'中的组名称的标题行开始，并且由下一组的开始或文件的结尾隐式结束。 每个键值对都必须包含在一个组中。  
键值对通常具有key=value的形式，除了具有格式key \[locale\] = value的本地化字符串以及形式为lang\_COUNTRY @ MODIFIER的区域标识符（其中COUNTRY和MODIFIER是可选的）之外。 忽略'='字符前后的空格。 value中的换行符，制表符，回车符和反斜杠字符分别转义为\\n，\\t，\\r和\\\\。 为了保留value中的前导空格，可以使用\\s转义。  
key files可以存储字符串（可能带有本地化变体），整数，布尔值和这些的列表。 列表由分隔符分隔，通常为';' 或者','。 要在列表中的value中使用列表分隔符，必须用反斜线前缀来转义它。  
这个语法受到Windows上常见的.ini文件的启发，但有一些重要的区别：  
1、.ini文件使用';' 字符开始注释，key files使用'＃'字符。  
2、key files不允许未分组的键，这意味着只有注释可以在第一组之前。  
3、key files始终以UTF-8编码。  
4、key和组名称区分大小写。 例如，名为\[GROUP\]的组与\[group\]不同。  
5、.ini文件没有强类型布尔类型，它们只有GetProfileInt（）。 在key files中，只允许true和false（小写）。  
请注意，与Desktop Entry Specification相比，key files中的组可能会多次包含相同的key; 最后一条胜利。 key files也可能包含多个具有相同名称的组; 他们合并在一起。 另一个区别是key files中的key和组名不限于ASCII字符。  
以下是加载key files并读取value的示例：

g_autoptr(GError) error = NULL;
    g_autoptr(GKeyFile) key_file = g_key_file_new ();
    
    
    if (!g_key_file_load_from_file (key_file, "key-file.ini", flags, &error))
    {
    	if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
    	  g_warning ("Error loading key file: %s", error->message);
    	return;
    }
    
    
    g_autofree gchar *val = g_key_file_get_string (key_file, "Group Name", "SomeKey", &error);
    if (val == NULL &&
        !g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND))
    {
    	g_warning ("Error finding key in key file: %s", error->message);
    	return;
    }
    else if (val == NULL)
    {
    	// Fall back to a default value.
    	val = g_strdup ("default-value");
    }

以下是创建和保存key files的示例：

g_autoptr(GKeyFile) key_file = g_key_file_new ();
    const gchar *val = …;
    g_autoptr(GError) error = NULL;
    
    
    g_key_file_set_string (key_file, "Group Name", "SomeKey", val);
    
    
    // Save as a file.
    if (!g_key_file_save_to_file (key_file, "key-file.ini", &error))
      {
        g_warning ("Error saving key file: %s", error->message);
        return;
      }
    
    
    // Or store to a GBytes for use elsewhere.
    gsize data_len;
    g_autofree guint8 *data = (guint8 *) g_key_file_to_data (key_file, &data_len, &error);
    if (data == NULL)
      {
        g_warning ("Error saving key file: %s", error->message);
        return;
      }
    g_autoptr(GBytes) bytes = g_bytes_new_take (g_steal_pointer (&data), data_len);

功能  
GKeyFile \*g\_key\_file\_new ()  
创建一个新的空的GKeyFile对象。 使用g\_key\_file\_load\_from\_file（），g\_key\_file\_load\_from\_data（），g\_key\_file\_load\_from\_dirs（）或g\_key\_file\_load\_from\_data\_dirs（）读取现有key files。  
返回  
一个空的GKeyFile。 \[代码完成后的需要释放数据\]  
由于：2.6  
  
voidg\_key\_file\_free ()  
清除key\_file中的所有keys和组，并将引用计数减1。如果引用计数达到零，则释放key files及其分配的所有内存。\[以C代码暴露，不一定在其他语言中可用\]  
参数  
key\_file  
一个GKeyFile  
由于：2.6  
  
GKeyFile \*g\_key\_file\_ref ()  
增加key\_file的引用计数。\[以C代码暴露，不一定在其他语言中可用\]  
参数  
key\_file  
一个GKeyFile  
返回  
相同的key\_file。  
从：2.32  
  
voidg\_key\_file\_unref ()  
将key\_file的引用计数减1。如果引用计数达到零，则释放key files及其分配的所有内存。  
参数  
key\_file  
一个GKeyFile  
从：2.32  
  
voidg\_key\_file\_set\_list\_separator ()  
设置用于分隔列表中的value的字符。 通常';' 或','被用作分隔符。 默认列表分隔符是';'。  
参数  
key\_file  
一个GKeyFile  
separator  
分离器  
由于：2.6  
  
gbooleang\_key\_file\_load\_from\_file ()  
将key files加载到空的GKeyFile结构中。  
如果操作系统在打开或读取文件时返回错误，则返回G\_FILE\_ERROR。 如果解析文件时出现问题，则返回G\_KEY\_FILE\_ERROR。  
该函数永远不会返回G\_KEY\_FILE\_ERROR\_NOT\_FOUND错误。 如果找不到该文件，则返回G\_FILE\_ERROR\_NOENT。  
参数  
key\_file  
一个空的GKeyFile结构  
file  
在GLib文件名编码中加载的文件名的路径。\[用给定类型覆盖解析的filename类型\]  
flags  
来自GKeyFileFlags的标志  
error  
返回GError的位置，或NULL  
返回  
如果可以加载密钥文件则为TRUE，否则为FALSE  
由于：2.6  
  
gbooleang\_key\_file\_load\_from\_data ()  
将内存中的key files加载到空的GKeyFile结构中。 如果对象不能被创建，那么错误被设置为GKeyFileError。  
参数  
key\_file  
一个空的GKeyFile结构  
data  
内存中的key files  
length  
以字节为单位的数据长度（或（gsize）-1，如果数据以'/0'结尾）  
flags  
来自GKeyFileFlags的标志  
error  
返回GError的位置，或NULL  
返回  
如果可以加载key files则为TRUE，否则为FALSE  
由于：2.6  
  
gbooleang\_key\_file\_load\_from\_bytes ()  
将data中的key files以字节为单位加载到空的GKeyFile结构中。 如果对象不能被创建，那么错误被设置为GKeyFileError。  
参数  
key\_file  
一个空的GKeyFile结构  
bytes  
一个GBytes  
flags  
来自GKeyFileFlags的标志  
error  
返回GError的位置，或NULL  
返回  
如果可以加载key files则为TRUE，否则为FALSE  
自：2.50  
  
gbooleang\_key\_file\_load\_from\_data\_dirs ()  
该函数在从g\_get\_user\_data\_dir（）和g\_get\_system\_data\_dirs（）返回的路径中查找名为file的key files，将文件加载到key\_file中，并在full\_path中返回该文件的完整路径。 如果文件无法加载，则会将错误设置为GFileError或GKeyFileError。  
参数  
key\_file  
一个空的GKeyFile结构  
file  
一个打开和解析文件名的相对路径。\[用给定类型覆盖解析的filename类型\]  
full\_path  
返回包含文件完整路径的字符串的位置，或NULL。\[参数是返回的结果\] \[用给定类型覆盖解析的filename类型\] \[可以传递NULL\]  
flags  
来自GKeyFileFlags的标志  
error  
返回GError的位置，或NULL  
返回  
如果可以加载key files则为TRUE，否则为FALSE  
由于：2.6  
  
gbooleang\_key\_file\_load\_from\_dirs ()  
该函数在search\_dirs指定的路径中查找名为file的key files，将文件加载到key\_file中，并在full\_path中返回文件的完整路径。  
如果在任何search\_dirs中找不到该文件，则返回G\_KEY\_FILE\_ERROR\_NOT\_FOUND。 如果找到文件但操作系统在打开或读取文件时返回错误，则返回G\_FILE\_ERROR。 如果解析文件时出现问题，则返回G\_KEY\_FILE\_ERROR。  
参数  
key\_file  
一个空的GKeyFile结构  
file  
一个打开和解析文件名的相对路径。\[用给定类型覆盖解析的filename类型\]  
search\_dirs  
以NULL结尾的目录数组进行搜索。\[参数指向数组的某一项，终止符为1\] \[容器和数组的定义元素为filename\]  
full\_path  
返回包含文件完整路径的字符串的位置，或NULL。\[参数是返回的结果\] \[用给定类型覆盖解析的filename类型\] \[可以传递NULL\]  
flags  
来自GKeyFileFlags的标志  
error  
返回GError的位置，或NULL  
返回  
如果可以加载密钥文件则为TRUE，否则为FALSE  
从：2.14  
  
gchar \*g\_key\_file\_to\_data ()  
该函数将key\_file作为字符串输出。  
请注意，此函数从不报告错误，所以将NULL赋值给error是安全的。  
参数  
key\_file  
一个GKeyFile  
length  
返回返回的字符串长度的位置，或NULL。\[参数是返回的结果\]\[可以传递NULL\]  
error  
返回GError的位置，或NULL  
返回  
一个新分配的字符串，其中包含GKeyFile的内容  
由于：2.6  
  
gbooleang\_key\_file\_save\_to\_file ()  
使用g\_file\_set\_contents（）将key\_file的内容写入文件名。  
由于g\_file\_set\_contents（）可能失败，此函数可能会失败。  
参数  
key\_file  
一个GKeyFile  
filename  
要写入的文件的名称  
error  
指向NULL GError的指针或NULL  
返回  
如果成功则为TRUE，否则返回FALSE并设置错误  
从：2.40  
  
gchar \*g\_key\_file\_get\_start\_group ()  
返回文件起始组的名称。  
参数  
key\_file  
一个GKeyFile  
返回  
key file的起始组。  
由于：2.6  
  
gchar \*\*g\_key\_file\_get\_groups ()  
返回用key\_file加载的key file中的所有组。 返回的组数组将以NULL结尾，所以长度可以选择为NULL。  
参数  
key\_file  
一个GKeyFile  
length  
返回返回组的数量的位置，或NULL。\[参数是返回的结果\]\[可以传递NULL\]  
返回  
一个新分配的以NULL结尾的字符串数组。 使用g\_strfreev（）释放它。\[参数指向数组的某一项，终止符为1\] \[代码完成后的需要释放数据\]  
由于：2.6  
  
gchar \*\*g\_key\_file\_get\_keys ()  
返回组名group\_name的所有keys。 返回的key的数组将以NULL结尾，所以长度可以选择为NULL。 如果找不到group\_name，则返回NULL，并将错误设置为G\_KEY\_FILE\_ERROR\_GROUP\_NOT\_FOUND。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
length  
返回返回位置的数量，或NULL。\[参数是返回的结果\]\[可以传递NULL\]  
error  
返回GError的位置，或NULL  
返回  
一个新分配的以NULL结尾的字符串数组。 使用g\_strfreev（）释放它。\[参数指向数组的某一项，终止符为1\] \[代码完成后的需要释放数据\]  
由于：2.6  
  
gbooleang\_key\_file\_has\_group ()  
查看key file是否具有组group\_name。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
返回  
如果group\_name是key\_file的一部分，则为TRUE，否则为FALSE。  
由于：2.6  
  
gbooleang\_key\_file\_has\_key ()  
查看key file是否在组group\_name中具有key。  
请注意，此功能严格遵循GError的规则; 返回值都带有含义并表示错误。 要使用此函数，您必须传递一个错误的GError指针，并检查它是否不为NULL以查看是否发生错误。  
语言绑定应该使用g\_key\_file\_get\_value（）来测试key是否存在。\[以C代码暴露，不一定在其他语言中可用\]  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
一个关键的名字  
error  
返回GError的位置  
返回  
如果key是group\_name的一部分，则为TRUE，否则为FALSE  
由于：2.6  
  
gchar \*g\_key\_file\_get\_value ()  
返回与group\_name下的key关联的原始值。 使用g\_key\_file\_get\_string（）来检索未转义的UTF-8字符串。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 如果找不到group\_name，则返回NULL，并将错误设置为G\_KEY\_FILE\_ERROR\_GROUP\_NOT\_FOUND。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
error  
返回GError的位置，或NULL  
返回  
一个新分配的字符串或NULL，如果找不到指定的键。  
由于：2.6  
  
gchar \*g\_key\_file\_get\_string ()  
返回与group\_name下的key关联的字符串值。 与g\_key\_file\_get\_value（）不同，此函数处理\\s等转义序列。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 如果找不到group\_name，则返回NULL，并将错误设置为G\_KEY\_FILE\_ERROR\_GROUP\_NOT\_FOUND。  
参数  
KEY\_FILE  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
error  
返回GError的位置，或NULL  
返回  
一个新分配的字符串或NULL，如果找不到指定的key。  
由于：2.6  
  
gchar \*g\_key\_file\_get\_locale\_string ()  
如果可用，则返回在给定语言环境中翻译的group\_name下与key关联的value。 如果locale设置为NULL，则假定当前区域设置。  
如果locale设置为非NULL，或者当前语言环境将在GKeyFile的生命周期内更改，则必须使用G\_KEY\_FILE\_KEEP\_TRANSLATIONS加载，以便为所有语言环境加载字符串。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 如果与key关联的值无法解释或者找不到合适的翻译，则返回未转换的值。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
locale  
一个区域标识符或NULL。\[NULL可以作为输入，输出，输入输出; 或作为返回值\]  
错误  
返回GError的位置，或NULL  
返回  
一个新分配的字符串或NULL，如果找不到指定的key。  
由于：2.6  
  
gbooleang\_key\_file\_get\_boolean ()  
以boolean值的形式返回与group\_name下的key关联的value。  
如果找不到key，则返回FALSE，并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 同样，如果与key关联的值不能被解释为布尔值，则返回FALSE并将错误设置为G\_KEY\_FILE\_ERROR\_INVALID\_VALUE。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
error  
返回GError的位置  
返回  
与key关联的值作为布尔值;如果key未找到或无法解析，则返回FALSE。  
由于：2.6  
  
gintg\_key\_file\_get\_integer ()  
以整数形式返回与group\_name下的key关联的value。  
如果找不到key，则返回0，并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 同样，如果与key关联的值不能被解释为整数，或者超出gint的范围，则返回0，并将错误设置为G\_KEY\_FILE\_ERROR\_INVALID\_VALUE。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
error  
返回GError的位置  
返回  
与key关联的value为整数，如果key未找到或无法解析，则返回0。  
由于：2.6  
  
gint64g\_key\_file\_get\_int64 ()  
返回与group\_name下的key关联的value，作为有符号的64位整数。 这与g\_key\_file\_get\_integer（）类似，但可以在不截断的情况下返回64位结果。  
参数  
key\_file  
一个非NULL的GKeyFile  
group\_name  
一个非NULL组名  
key  
一个非NULL键  
error  
返回GError的位置  
返回  
与key相关的value作为有符号的64位整数，如果未找到或无法解析key，则返回0。  
从：2.26  
  
guint64g\_key\_file\_get\_uint64 ()  
返回与group\_name下的key相关的value，作为无符号的64位整数。 这与g\_key\_file\_get\_integer（）类似，但可以在不截断的情况下返回大的肯定结果。  
参数  
key\_file  
一个非NULL的GKeyFile  
group\_name  
一个非NULL组名  
key  
一个非NULL键  
error  
返回GError的位置  
返回  
与该key相关联的value作为无符号的64位整数，如果该key未找到或无法解析，则返回0。  
从：2.26  
  
gdoubleg\_key\_file\_get\_double ()  
以double形式返回与group\_name下的key关联的value。 如果group\_name为NULL，则使用start\_group。  
如果找不到key，则返回0.0并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 同样，如果与key关联的value不能被解释为double，则返回0.0，并将错误设置为G\_KEY\_FILE\_ERROR\_INVALID\_VALUE。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
error  
返回GError的位置  
返回  
与该key相关联的value为double，如果该key未找到或无法解析，则返回0.0。  
从：2.12  
  
gchar \*\*g\_key\_file\_get\_string\_list ()  
返回与group\_name下的key关联的value。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 如果找不到group\_name，则返回NULL，并将错误设置为G\_KEY\_FILE\_ERROR\_GROUP\_NOT\_FOUND。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
length  
返回返回的字符串数量的位置，或NULL。  
error  
返回GError的位置，或NULL  
返回  
以NULL结尾的字符串数组或NULL，如果找不到指定的key。 该数组应该用g\_strfreev（）释放。  
  
gchar \*\*g\_key\_file\_get\_locale\_string\_list ()  
如果可用，则返回在给定语言环境中翻译的group\_name下与key关联的value。 如果locale设置为NULL，则假定当前区域设置。  
如果locale设置为非NULL，或者当前语言环境将在GKeyFile的生命周期内更改，则必须使用G\_KEY\_FILE\_KEEP\_TRANSLATIONS加载，以便为所有语言环境加载字符串。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 如果与key相关的value无法解释或者找不到合适的翻译，则返回未转换的值。 返回的数组以NULL结尾，所以长度可以选择为NULL。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
locale  
一个区域标识符或NULL。  
length  
返回返回的字符串数量或NULL的位置。  
error  
返回GError或NULL的位置  
返回  
一个新分配的以NULL结尾的字符串数组，如果未找到该key，则返回NULL。 字符串数组应该用g\_strfreev（）来释放。  
  
gboolean \*g\_key\_file\_get\_boolean\_list ()  
返回与group\_name下的key关联的value，作为布尔值。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 同样，如果与key关联的value不能被解释为布尔值，则返回NULL，并将错误设置为G\_KEY\_FILE\_ERROR\_INVALID\_VALUE。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
length  
返回的布尔值的数量。  
error  
返回GError的位置  
返回  
与key关联的value作为布尔值列表;如果key未找到或无法解析，则返回NULL。 返回的布尔值列表应该在不再需要时使用g\_free（）来释放。  
  
gint \*g\_key\_file\_get\_integer\_list ()  
以整数形式返回与group\_name下的key关联的value。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 同样，如果与key相关的value不能被解释为整数，或者超出gint的范围，则返回NULL，并将错误设置为G\_KEY\_FILE\_ERROR\_INVALID\_VALUE。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
length  
返回的整数数量。  
error  
返回GError的位置  
返回  
与key关联的value作为整数列表;如果key未找到或无法解析，则返回NULL。 当不再需要时，返回的整数列表应该用g\_free（）来释放。  
  
gdouble \*g\_key\_file\_get\_double\_list ()  
返回与group\_name下的key相关的value作为双精度值。  
如果找不到key，则返回NULL并将错误设置为G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND。 同样，如果与key关联的value不能被解释为双精度型，则返回NULL，并将错误设置为G\_KEY\_FILE\_ERROR\_INVALID\_VALUE。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
length  
返回的双打数量。  
error  
返回GError的位置  
返回  
与key相关联的value作为双精度列表，如果key未找到或无法解析，则返回NULL。 当不再需要时，返回的双打列表应该用g\_free（）释放。  
  
gchar \*g\_key\_file\_get\_comment ()  
从group\_name中检索key上的注释。 如果key为NULL，则将从group\_name上面读取注释。 如果key和group\_name都为NULL，则将从文件的第一组上方读取注释。  
请注意，返回的字符串包含'＃'注释标记。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名，或NULL。  
key  
关键  
error  
返回GError的位置  
返回  
一个应该用g\_free（）释放的注释  
由于：2.6  
  
voidg\_key\_file\_set\_value ()  
将一个新value与group\_name下的key关联。  
如果找不到key，则会创建该key。 如果找不到group\_name，则会创建它。 要设置可能包含需要转义的字符（如换行符或空格）的UTF-8字符串，请使用g\_key\_file\_set\_string（）。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
value  
一个字符串  
由于：2.6  
  
voidg\_key\_file\_set\_string ()  
将新的字符串value与group\_name下的key关联。 如果找不到key，则会创建该key。 如果找不到group\_name，则会创建它。 与g\_key\_file\_set\_value（）不同，此函数处理需要转义的字符，如换行符。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
string  
一个字符串  
由于：2.6  
  
voidg\_key\_file\_set\_locale\_string ()  
为group\_name下的key和语言环境关联一个字符串value。 如果找不到key的翻译，则会创建它。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
locale  
一个区域标识符  
string  
一个字符串  
由于：2.6  
  
voidg\_key\_file\_set\_boolean ()  
将一个新的布尔值与group\_name下的key关联。 如果找不到key，则会创建该key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
value  
TRUE或FALSE  
由于：2.6  
  
voidg\_key\_file\_set\_integer ()  
将一个新的整数value与group\_name下的key关联。 如果找不到key，则会创建该key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
value  
一个整数值  
由于：2.6  
  
voidg\_key\_file\_set\_int64 ()  
将一个新的整数值与group\_name下的key关联。 如果找不到key，则会创建该key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
value  
一个整数值  
从：2.26  
  
voidg\_key\_file\_set\_uint64 ()  
将一个新的整数值与group\_name下的key关联。 如果找不到key，则会创建该key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
value  
一个整数值  
从：2.26  
  
voidg\_key\_file\_set\_double ()  
将一个新的double值与group\_name下的key关联。 如果找不到key，则会创建该key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
value  
double值  
从：2.12  
  
voidg\_key\_file\_set\_string\_list ()  
在group\_name下关联字符串value列表。 如果找不到key，则会创建该key。 如果找不到group\_name，则会创建它。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
list  
一个字符串值的数组。  
length  
列表中的字符串值数量  
由于：2.6  
  
voidg\_key\_file\_set\_locale\_string\_list ()  
将group\_name下的key和语言环境的字符串值列表关联起来。 如果找不到key的翻译，则会创建它。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
locale  
一个区域标识符  
list  
一个以NULL结尾的语言环境字符串值数组。  
length  
列表的长度  
由于：2.6  
  
voidg\_key\_file\_set\_boolean\_list ()  
将布尔值列表与group\_name下的key关联。 如果找不到key，则会创建该key。 如果group\_name为NULL，则使用start\_group。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
list  
一个布尔值数组。  
length  
列表的长度  
由于：2.6  
  
voidg\_key\_file\_set\_integer\_list ()  
将整数值列表与group\_name下的key关联。 如果找不到key，则会创建该key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
list  
整数值的数组。  
length  
列表中的整数值个数  
由于：2.6  
  
voidg\_key\_file\_set\_double\_list ()  
将double值的列表与group\_name下的key关联。 如果找不到key，则会创建该key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
关键  
list  
一个double值的数组。  
length  
列表中的double值的数量  
从：2.12  
  
gbooleang\_key\_file\_set\_comment ()  
在group\_name的上方放置注释。  
如果key为NULL，则注释将写在group\_name上方。 如果key和group\_name都为NULL，则注释将写入文件中第一个组的上方。  
请注意，该函数在每行注释前加上一个'＃'注释标记。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名，或NULL。  
key  
关键。  
comment  
一条评论  
error  
返回GError的位置  
返回  
如果评论已写入则为TRUE，否则为FALSE  
由于：2.6  
  
gbooleang\_key\_file\_remove\_group ()  
从key file中删除指定的group\_name。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
error  
返回GError或NULL的位置  
返回  
如果该组被删除则为TRUE，否则为FALSE  
由于：2.6  
  
gbooleang\_key\_file\_remove\_key ()  
从key file中删除group\_name中的key。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名  
key  
要删除的关键名称  
error  
返回GError或NULL的位置  
返回  
如果键被移除则为TRUE，否则为FALSE  
由于：2.6  
  
gbooleang\_key\_file\_remove\_comment ()  
从group\_name删除以上注释的注释。 如果key为NULL，则在group\_name上方删除注释。 如果key和group\_name都为NULL，则注释将被删除到文件中第一个组的上方。  
参数  
key\_file  
一个GKeyFile  
group\_name  
一个组名，或NULL。  
key  
关键。  
error  
返回GError的位置  
返回  
如果评论已被删除则为TRUE，否则为FALSE  
由于：2.6  
  
类型和值  
 GKeyFile  
GKeyFile结构只包含私有数据，不应直接访问。  
  
\#defineG\_KEY\_FILE\_ERROR  
密钥文件解析的错误域。 此域中的错误将来自GKeyFileError枚举。  
有关错误域的信息，请参阅GError。  
  
enumGKeyFileError  
密钥文件解析返回的错误代码。  
成员  
G\_KEY\_FILE\_ERROR\_UNKNOWN\_ENCODING  
被解析的文本是未知的编码  
G\_KEY\_FILE\_ERROR\_PARSE  
文件格式不正确  
G\_KEY\_FILE\_ERROR\_NOT\_FOUND  
该文件未找到  
G\_KEY\_FILE\_ERROR\_KEY\_NOT\_FOUND  
没有找到请求的密钥  
G\_KEY\_FILE\_ERROR\_GROUP\_NOT\_FOUND  
没有找到请求的组  
G\_KEY\_FILE\_ERROR\_INVALID\_VALUE  
一个值不能被解析  
  
enumGKeyFileFlags  
影响解析的标志。  
成员  
G\_KEY\_FILE\_NONE  
没有标志，默认行为  
G\_KEY\_FILE\_KEEP\_COMMENTS  
如果您打算将key file的（可能已修改的）内容写回文件，请使用此标志; 否则当key file被写回时，所有注释都将丢失。  
G\_KEY\_FILE\_KEEP\_TRANSLATIONS  
如果您打算将key file的（可能已修改的）内容写回文件，请使用此标志; 否则只有当前语言的翻译才会被写回。

下面提供一下读取文件和写文件的示例代码，代码几乎将所有函数包含进入。

读文件代码

首先准备一个.ini文件key-file.ini

# this is just an example
    # there can be comments before the first group
    
    [First Group]
    
    Name=Key File Example\tthis value shows\nescaping 测试
    Booleanval = false
    Integerval = 12355
    Int64val = 9223372036854775800
    Uint64val = 18446744073709551615
    Doubleval = 3.1415926
    # localized strings are stored in multiple key-value pairs
    Welcome=Hello
    Welcome[de]=Hallo
    Welcome[fr_FR]=Bonjour
    Welcome[it]=Ciao
    Welcome[be@latin]=Hello
    
    [Another Group]
    
    Numbers=2;20;-200;0
    Strings = string1;string2;string3;string4;string5
    Booleans=true;false;true;true
    Doubles = 1.1;42.111;3.221;462.12345

readkeyvalue.c

#include <glib.h>
    #include <glib/gprintf.h>
    
    int main(int argc, char **argv)
    {
    	g_printf ("%s in\n", __func__);
    
    	GError *error = NULL;
    	GKeyFile *key_file = g_key_file_new ();
    
    	if (!g_key_file_load_from_file (key_file, "key-file.ini", G_KEY_FILE_KEEP_TRANSLATIONS|G_KEY_FILE_KEEP_COMMENTS, &error))
    	{
    		if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
    			g_warning ("Error loading key file: %s", error->message);
    		if (g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
    			g_warning ("Error loading key file: %s", error->message);
    		g_error_free (error);
    		g_key_file_free (key_file);
    		return 0;
    	}
    	
    	gchar *start_group = g_key_file_get_start_group (key_file);
    	if (start_group == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("start_group is NULL");
    	}
    	else
    	{
    		g_printf ("start_group = %s\n", start_group);
    		g_free(start_group);
    	}
    	
    	gsize length;
    	gchar **groups = g_key_file_get_groups (key_file, &length);
    	if (groups == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("groups is NULL");
    	}
    	else
    	{
    		g_printf ("groups length = %ld\n", length);
    		gint i;
    		for (i=0; i<length; ++i)
    			g_printf ("groups[%d] = %s\n", i, groups[i]);
    		g_strfreev (groups);
    	}
    	
    	gchar **keys = g_key_file_get_keys (key_file, "First Group", &length, &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get keys key_file: %s", error->message);
    	}
    	else if (keys == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("keys is NULL");
    	}
    	else
    	{
    		g_printf ("keys length = %ld\n", length);
    		gint i;
    		for (i=0; i<length; ++i)
    			g_printf ("keys[%d] = %s\n", i, keys[i]);
    		g_strfreev (keys);
    	}
    
    	g_key_file_has_group (key_file, "First Group") ? g_printf ("key_file has group First Group\n") : g_printf ("key_file not has  group First Group\n");
    	g_key_file_has_group (key_file, "Second Group") ? g_printf ("key_file has group Second Group\n") : g_printf ("key_file not has group Second Group\n");
    	
    	gboolean has_key = g_key_file_has_key (key_file,
    											"First Group",
    											"Welcome",
    											&error);
    	if( error != NULL )
    	{
    		g_warning ("Error has key key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else
    	{
    		has_key ? g_printf ("key_file has key Welcome\n") : g_printf ("key_file not has key Welcome\n");
    	}
    	
    	gchar *get_value =
    	g_key_file_get_value (key_file,
    						  "First Group",
    						  "Name",
    						  &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get value key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (get_value == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("get_value is NULL");
    	}
    	else
    	{
    		g_printf ("get_value Name = %s\n", get_value);
    		g_free (get_value);
    	}
    	
    	gchar *get_locale_string = 
    	g_key_file_get_locale_string (key_file,
    								  "First Group",
    								  "Welcome",
    								  "fr_FR",
    								  &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get locale string key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (get_locale_string == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("get_locale_string is NULL");
    	}
    	else
    	{
    		g_printf ("get_locale_string Welcome[fr_FR] = %s\n", get_locale_string);
    		g_free (get_locale_string);
    	}
    
    	gchar * get_string = 
    	g_key_file_get_string (key_file,
    						   "First Group",
    						   "Name",
    						   &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get string key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (get_string == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("get_string is NULL");
    	}
    	else
    	{
    		g_printf ("get_string Name = %s\n", get_string);
    		g_free (get_string);
    	}
    	
    	gboolean get_boolean = 
    	g_key_file_get_boolean (key_file,
    							"First Group",
    						    "Booleanval",
    						    &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get boolean key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else
    	{
    		get_boolean ? g_printf ("key_file Booleanval is true\n") : g_printf ("key_file Booleanval is false\n");
    	}
    	
    	gint get_integer =
    	g_key_file_get_integer (key_file,
    							"First Group",
    							"Integerval",
    							&error);
    	if( error != NULL )
    	{
    		g_warning ("Error get integer key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else
    	{
    		g_printf ("get_integer Integerval = %d\n", get_integer);
    	}
    	
    	gint64 get_int64 =
    	g_key_file_get_int64 (key_file,
    						  "First Group",
    						  "Int64val",
    						  &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get int64 key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else
    	{
    		g_printf ("get int64 Int64val = %ld\n", get_int64);
    	}
    	
    	guint64 get_uint64 =
    	g_key_file_get_uint64 (key_file,
    						  "First Group",
    						  "Uint64val",
    						  &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get uint64 key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else
    	{
    		g_printf ("get uint64 Uint64val = %lu\n", get_uint64);
    	}
    	
    	gdouble get_double =
    	g_key_file_get_double (key_file,
    						   "First Group",
    						   "Doubleval",
    						   &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get double key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else
    	{
    		g_printf ("get double Doubleval = %f\n", get_double);
    	}
    	
    	gchar **string_list =
    	g_key_file_get_string_list (key_file,
    						        "Another Group",
    						        "Strings",
    								&length,
    								&error);
    	if( error != NULL )
    	{
    		g_warning ("Error get string list key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (string_list == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("string_list is NULL");
    	}
    	else
    	{
    		g_printf ("Strings length = %ld\n", length);
    		gint i;
    		for (i=0; i<length; ++i)
    			g_printf ("Strings[%d] = %s\n", i, string_list[i]);
    		g_strfreev (string_list);
    	}
    	
    	/*g_key_file_get_locale_string_list the same as g_key_file_get_locale_string*/
    	
    	gboolean *boolean_list =
    	g_key_file_get_boolean_list (key_file,
    						         "Another Group",
    						         "Booleans",
    								 &length,
    								 &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get boolean list key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (boolean_list == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("boolean_list is NULL");
    	}
    	else
    	{
    		g_printf ("Booleans length = %ld\n", length);
    		gint i;
    		for (i=0; i<length; ++i)
    			g_printf ("Booleans[%d] = %s\n", i, (boolean_list[i]?"true":"false"));
    		g_free (boolean_list);
    	}
    	
    	gint *integer_list =
    	g_key_file_get_integer_list (key_file,
    						         "Another Group",
    						         "Numbers",
    								 &length,
    								 &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get integer list key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (integer_list == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("integer_list is NULL");
    	}
    	else
    	{
    		g_printf ("Numbers length = %ld\n", length);
    		gint i;
    		for (i=0; i<length; ++i)
    			g_printf ("Numbers[%d] = %d\n", i, integer_list[i]);
    		g_free (integer_list);
    	}
    	
    	gdouble *double_list =
    	g_key_file_get_double_list (key_file,
    						        "Another Group",
    						        "Doubles",
    								&length,
    								&error);
    	if( error != NULL )
    	{
    		g_warning ("Error get double list key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (double_list == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("double_list is NULL");
    	}
    	else
    	{
    		g_printf ("Doubles length = %ld\n", length);
    		gint i;
    		for (i=0; i<length; ++i)
    			g_printf ("Doubles[%d] = %f\n", i, double_list[i]);
    		g_free (double_list);
    	}
    	
    	gchar *get_comment =
    	g_key_file_get_comment (key_file,
    							"First Group",
    							"Welcome",
    							&error);
    	if( error != NULL )
    	{
    		g_warning ("Error get comment list key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (get_comment == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("get_comment is NULL");
    	}
    	else
    	{
    		g_printf ("Comment = %s\n", get_comment);
    		g_free (get_comment);
    	}
    	
    //----------------------------DATA-------------------------------//	
    	const gchar *data =
    	g_key_file_to_data (key_file,
    						&length,
    						&error);
    	g_printf ("key file to data length = %ld\n", length);
    	g_printf ("key file to data = \n%s\n", data);
    
    	if (!g_key_file_load_from_data (key_file, data, (gsize)-1, G_KEY_FILE_KEEP_TRANSLATIONS|G_KEY_FILE_KEEP_COMMENTS, &error))
    	{
    		g_warning ("Error loading key data: %s", error->message);
    		g_error_free (error);
    		g_key_file_free (key_file);
    		return 0;
    	}
    	
    	get_string = 
    	g_key_file_get_string (key_file,
    						   "First Group",
    						   "Name",
    						   &error);
    	if( error != NULL )
    	{
    		g_warning ("Error get string key_file: %s", error->message);
    		g_error_free (error);
    		error = NULL;
    	}
    	else if (get_string == NULL)
    	{
    		// Fall back to a default value.
    		g_warning ("get_string is NULL");
    	}
    	else
    	{
    		g_printf ("get_string Name = %s\n", get_string);
    		g_free (get_string);
    	}
    //----------------------------data_dirs-------------------------------//	
    	if(!g_setenv ("XDG_DATA_HOME", "/home/renz/ggtest", FALSE))
    	{
    		g_warning ("g_setenv is false");
    	}
    	g_printf ("g_get_user_data_dir() = %s\n", g_get_user_data_dir ());
    	
    	gchar *full_path = NULL;
    	if (!g_key_file_load_from_data_dirs (key_file, "key-file.ini", &full_path, G_KEY_FILE_KEEP_TRANSLATIONS|G_KEY_FILE_KEEP_COMMENTS, &error))
    	{
    		g_warning ("Error loading from data dirs: %s", error->message);
    		g_error_free (error);
    		g_key_file_free (key_file);
    		return 0;
    	}
    
    	if(full_path != NULL)
    	{
    		g_printf ("full_path = %s\n", full_path);
    	}
    
    	g_key_file_free (key_file);
    	g_printf ("%s out\n", __func__);
    	
        return 0;
    }

输出结果：

main in
    start_group = First Group
    groups length = 2
    groups[0] = First Group
    groups[1] = Another Group
    keys length = 11
    keys[0] = Name
    keys[1] = Booleanval
    keys[2] = Integerval
    keys[3] = Int64val
    keys[4] = Uint64val
    keys[5] = Doubleval
    keys[6] = Welcome
    keys[7] = Welcome[de]
    keys[8] = Welcome[fr_FR]
    keys[9] = Welcome[it]
    keys[10] = Welcome[be@latin]
    key_file has group First Group
    key_file not has group Second Group
    key_file has key Welcome
    get_value Name = Key File Example\tthis value shows\nescaping 测试
    get_locale_string Welcome[fr_FR] = Bonjour
    get_string Name = Key File Example	this value shows
    escaping 测试
    key_file Booleanval is false
    get_integer Integerval = 12355
    get int64 Int64val = 9223372036854775800
    get uint64 Uint64val = 18446744073709551615
    get double Doubleval = 3.141593
    Strings length = 5
    Strings[0] = string1
    Strings[1] = string2
    Strings[2] = string3
    Strings[3] = string4
    Strings[4] = string5
    Booleans length = 4
    Booleans[0] = true
    Booleans[1] = false
    Booleans[2] = true
    Booleans[3] = true
    Numbers length = 4
    Numbers[0] = 2
    Numbers[1] = 20
    Numbers[2] = -200
    Numbers[3] = 0
    Doubles length = 4
    Doubles[0] = 1.100000
    Doubles[1] = 42.111000
    Doubles[2] = 3.221000
    Doubles[3] = 462.123450
    Comment =  localized strings are stored in multiple key-value pairs
    
    key file to data length = 566
    key file to data = 
    # this is just an example
    # there can be comments before the first group
    
    [First Group]
    
    Name=Key File Example\tthis value shows\nescaping 测试
    Booleanval=false
    Integerval=12355
    Int64val=9223372036854775800
    Uint64val=18446744073709551615
    Doubleval=3.1415926
    # localized strings are stored in multiple key-value pairs
    Welcome=Hello
    Welcome[de]=Hallo
    Welcome[fr_FR]=Bonjour
    Welcome[it]=Ciao
    Welcome[be@latin]=Hello
    
    [Another Group]
    
    Numbers=2;20;-200;0
    Strings=string1;string2;string3;string4;string5
    Booleans=true;false;true;true
    Doubles=1.1;42.111;3.221;462.12345
    
    get_string Name = Key File Example	this value shows
    escaping 测试
    g_get_user_data_dir() = /home/renz/ggtest
    full_path = /home/renz/ggtest/key-file.ini
    main out

写文件例程

输出结果：

main in
    key file to data length = 566
    key file to data = 
    # this is just an example
    # there can be comments before the first group
    
    [First Group]
    
    Name=Key File Example\tthis value shows\nescaping 测试
    Booleanval=false
    Integerval=12355
    Int64val=9223372036854775800
    Uint64val=18446744073709551615
    Doubleval=3.1415926
    # localized strings are stored in multiple key-value pairs
    Welcome=Hello
    Welcome[de]=Hallo
    Welcome[fr_FR]=Bonjour
    Welcome[it]=Ciao
    Welcome[be@latin]=Hello
    
    [Another Group]
    
    Numbers=2;20;-200;0
    Strings=string1;string2;string3;string4;string5
    Booleans=true;false;true;true
    Doubles=1.1;42.111;3.221;462.12345
    
    main out

key-file\_ex.ini

[First Group]
    
    Booleanval=false
    Integerval=12355
    Int64val=9223372036854775800
    Uint64val=18446744073709551615
    Doubleval=3.1415926
    # localized strings are stored in multiple key-value pairs
    Welcome=Hello
    Welcome[de]=Hallo
    Welcome[fr_FR]=Bonjour
    Welcome[it]=Ciao
    Welcome[be@latin]=Hello
    
    [Create Group]
    new key=new vlaue
    new string=Key File Example	this value shows\nescaping 测试
    new string[der]=heillen
    new boolean=true
    new integer=233333
    new int64=9223372036854775744
    new uint64=18446744073709551600
    new double=3.1415926000000001
    new string list=aaaa;bbbbbb;cccccccccc;
    new boolean list=true;false;false;true;
    new integer list=123;444;122;4;
    #g_key_file_set_comment
    new double list=1.1000000000000001;2.2000000000000002;3.2999999999999998;4.4000000000000004;5.5;