Glib学习（5） 字符串 Strings

学过面向对象语言的同学一定都知道String类，一定知道这个类对字符串的操作是多麽的方便，但是c语言中是没有这个类，甚至没有类的概念，但是glib帮我们做的这个“类”  GString

除了使用gchar *进行字符串处理以外，Glib还定义了一种新的数据类型： GString。
它类似于标准C的字符串类型，但是GString能够自动增长。它的字符串数据是以NULL结尾的。
这些特性可以防止程序中的缓冲溢出。这是一种非常重要的特性。

GString是一种动态字符串数据结构，提供了丰富灵活方便的API，无需手工分配内存，无需担心缓冲区溢出。

先说一下GString的结构体定义

GString

typedef struct {
  gchar  *str;
  gsize len;    
  gsize allocated_len;
} GString;

这里就不用多解释了，str是字符串的指针，len是字符串长度，allocated_len是前面说的会多申请一段内存，申请的大小是由一定的算法，并不是保留一个固定值，下面的例子程序中有相关的效果，可以留意一下。

然后是glib提供的功能函数：

Synopsis

#include  ; *  (const  *init); *  (const  *init,  len); *  ( dfl_size); *  ( *string,
                                                         const  *rval);
#define  #define  void  ( *string,
                                                         const  *format,
                                                         va_list args);
void  ( *string,
                                                         const  *format,
                                                         va_list args);
void  ( *string,
                                                         const  *format,
                                                         ...);
void  ( *string,
                                                         const  *format,
                                                         ...); *  ( *string,
                                                         const  *val); *  ( *string,  c); *  ( *string,  wc); *  ( *string,
                                                         const  *val,  len); *  ( *string,
                                                         const char *unescaped,
                                                         const char *reserved_chars_allowed,  allow_utf8); *  ( *string,
                                                         const  *val); *  ( *string,  c); *  ( *string,  wc); *  ( *string,
                                                         const  *val,  len); *  ( *string,  pos,
                                                         const  *val); *  ( *string,  pos,  c); *  ( *string,  pos,  wc); *  ( *string,  pos,
                                                         const  *val,  len); *  ( *string,  pos,
                                                         const  *val); *  ( *string,  pos,
                                                         const  *val,  len); *  ( *string,  pos,  len); *  ( *string,  len); *  ( *string,  len); *  ( *string,  free_segment); *  ( *string); *  ( *string);   (const  *str);   (const  *v,
                                                         const  *v2);

用下面的函数创建新的GString变量： GString *g_string_new( gchar *init ); 这个函数创建一个GString，将字符串值init复制到GString中，返回一个指向它的指针。 如果init参数是NULL，创建一个空GString。 
void g_string_free( GString *string, gint free_segment ); 这个函数释放string所占据的内存。
free_segment参数是一个布尔类型变量。如果 free_segment参数是TRUE，它还释放其中的字符数据。
 GString *g_string_assign( GString *lval, const gchar *rval ); 这 个函数将字符从rval复制到lval，销毁lval的原有内容。注意，如有必要， lval会被加长以容纳字符串的内容。这一点和标准的字符串复制函数strcpy( )相同。下面的函数的意义都是显而易见的。
其中以_ c结尾的函数接受一个字符，而不是字符串。 
截取string字符串，生成一个长度为len的子串： GString *g_string_truncate( GString *string, gint len ); 
将字符串val追加在string后面，返回一个新字符串： GString *g_string_append( GString *string, gchar *val ); 
将字符c追加到string后面，返回一个新的字符串： GString *g_string_append_c( GString *string, gchar c ); 
将字符串val插入到string前面，生成一个新字符串： GString *g_string_prepend( GString *string, gchar *val ); 
将字符c插入到string前面，生成一个新字符串： GString *g_string_prepend_c( GString *string, gchar c ); 
将一个格式化的字符串写到string中，类似于标准的sprint f函数： void g_string_sprintf( GString *string, gchar *fmt, . . . ) ; 
将一个格式化字符串追加到string后面，与上一个函数略有不同： void g_string_sprintfa ( GString *string, gchar *fmt, ... );

下面用一个例子程序说明几个常用函数的用法

#include

int main(int argc,char **argv) {

//    GString* g_string_new(const gchar *init);   根据所给的字符串建立适当长度的GString，并自动创建适当长度的allocated_len，创建的时候将字符串init复制到GString中。
    GString *string = g_string_new("Justin");
    g_print("g_string_new(\"Justin\"); len = %d, allocated_len = %d\n",
            string->len, string->allocated_len);

//    若不使用GString时，可以使用g_string_free()释放，第二个参数如果为TRUE，会连同字符串也是放掉。
    g_string_free(string, TRUE);

//    GString* g_string_new_len(const gchar *init, gssize len);     指定len来建立GString，因为是自行制定的长度，所以len必须超过init的长度。
    string = g_string_new_len("Justin", 32);
    g_print("g_string_new_len(\"Justin\", 32); len = %d, allocated_len = %d\n",
            string->len, string->allocated_len);
    g_string_free(string, TRUE);

//    GString* g_string_sized_new(gsize dfl_size);      指定allocated_len建立GString，函数会根据需要的长度值自动分配长度，也就是不一定会分配设置的长度，但一定会比设定的长度大。
    string = g_string_sized_new(32);
    g_printf("g_string_sized_new(32); len = %d, allocated_len = %d\n",
            string->len, string->allocated_len);
    g_string_free(string, TRUE);


    GString *t=g_string_new("Hello Laomeng.");
    GString *s=g_string_new("Hello Laoli.");

//    g_string_equal()    判断两个GString的字符串内容是否相同
    if(g_string_equal(s,t))
    {
        g_print("g_string_equal(s,t); %s  == %s\n",s->str,t->str);
    }
    else
    {
        g_print("g_string_equal(s,t); %s != %s\n",s->str,t->str);
    }
    g_string_free(s, TRUE);
    g_string_free(t, TRUE);

    string = g_string_new("first str!");
//     GString* g_string_append (GString *string,const gchar *val);     在字符串string后面追加字符串val
    g_string_append(string, "second str!");
    g_print("g_string_append(string, \"second str!\"); %s\n", string->str);

//    GString* g_string_truncate(GString *string,gsize len); 截断字符串，保留前len个字符
    g_string_truncate(string,5);
    g_print("g_string_truncate(string,5);  string:  %s, len = %d, allocated_len = %d\n",string->str, string->len , string->allocated_len);

//     GString* g_string_prepend (GString *string,const gchar *val);     在字符串string前面追加字符串val
    g_string_prepend(string, "prepend str!");
    g_print("g_string_prepend(string, \"prepend str!\"); string:%s\n", string->str);

//     GString* g_string_insert (GString *string,gssize pos,const gchar *val);     将字符串插入到pos处
    g_string_insert(string, sizeof("prepend str!")-1 , "insert str!");
    g_print("g_string_insert(string, sizeof(\"prepend str!\") , \"insert str!\"); %s\n", string->str);

//    void g_string_printf(GString *string, const gchar *format, ...);  格式化一个字符串，和sprintf用法一样，只是赋值给一个GString，string里面以前的数据被销毁了
    g_string_printf(string,"%d + %d = %d", 100, 200, 100+200);
    g_print("g_string_printf(); GString: %s, len = %d, allocated_len = %d \n",string->str, string->len , string->allocated_len);

//    void g_string_append_printf(GString *string, const gchar *format, ...);  格
式化一个字符串，和g_string_printf很相似，只是不销毁string里面的数据，而是在后面追加
    g_string_append_printf(string,"\t %d * %d = %d", 100,200,100*200);
    g_print("g_string_append_printf(); GString: %s, len = %d, allocated_len = %d \n",string->str, string->len , string->allocated_len);

    g_string_free(string,TRUE);

    string = g_string_new("abcdefgABCDEFG");

//    g_string_ascii_up()或g_utf8_strup() 转换GString中的字符串为小写
    g_string_ascii_up(string);
    g_printf("Upper: %s\n", string->str);
//    g_string_ascii_down()或g_utf8_strdown()转换GString中的字符串为大写
    g_string_ascii_down(string);
    g_printf("Down: %s\n", string->str);

    g_string_free(string,TRUE);

    return 0;

}

运行结果：

[plain] view plain copy

1. linux@ubuntu:~/16021/glibdemo$ gcc -o gstring gstring.c -lglib-2.0  
2. linux@ubuntu:~/16021/glibdemo$ ./gstring   
3. g_string_new("Justin"); len = 6, allocated_len = 16  
4. g_string_new_len("Justin", 32); len = 32, allocated_len = 64  
5. g_string_sized_new(32); len = 0, allocated_len = 64  
6. g_string_equal(s,t); Hello Laoli. != Hello Laomeng.  
7. g_string_append(string, "second str!"); first str!second str!  
8. g_string_truncate(string,5);  string:  first, len = 5, allocated_len = 32  
9. g_string_prepend(string, "prepend str!"); string:prepend str!first  
10. g_string_insert(string, sizeof("prepend str!") , "insert str!"); prepend str!insert str!first  
11. g_string_printf(); GString: 100 + 200 = 300, len = 15, allocated_len = 32   
12. g_string_append_printf(); GString: 100 + 200 = 300   100 * 200 = 20000, len = 34, allocated_len = 64   
13. Upper: ABCDEFGABCDEFG  
14. Down: abcdefgabcdefg  
15. linux@ubuntu:~/16021/glibdemo$