Glib学习（5）字符串 Strings

最新推荐文章于 2024-01-25 19:00:34 发布

andylauren

最新推荐文章于 2024-01-25 19:00:34 发布

阅读量5.4k

点赞数

分类专栏： glib 文章标签： glib GString

本文链接：https://blog.csdn.net/andylauren/article/details/51406811

版权

glib 专栏收录该内容

33 篇文章 78 订阅

订阅专栏

先上说明文档网址：http://web.mit.edu/barnowl/share/gtk-doc/html/glib/glib-Strings.html

学过面向对象语言的同学一定都知道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 <glib.h>


                    GString;
GString*            g_string_new                        (const gchar *init);
GString*            g_string_new_len                    (const gchar *init,
                                                         gssize len);
GString*            g_string_sized_new                  (gsize dfl_size);
GString*            g_string_assign                     (GString *string,
                                                         const gchar *rval);
#define             g_string_sprintf
#define             g_string_sprintfa
void                g_string_vprintf                    (GString *string,
                                                         const gchar *format,
                                                         va_list args);
void                g_string_append_vprintf             (GString *string,
                                                         const gchar *format,
                                                         va_list args);
void                g_string_printf                     (GString *string,
                                                         const gchar *format,
                                                         ...);
void                g_string_append_printf              (GString *string,
                                                         const gchar *format,
                                                         ...);
GString*            g_string_append                     (GString *string,
                                                         const gchar *val);
GString*            g_string_append_c                   (GString *string,
                                                         gchar c);
GString*            g_string_append_unichar             (GString *string,
                                                         gunichar wc);
GString*            g_string_append_len                 (GString *string,
                                                         const gchar *val,
                                                         gssize len);
GString*            g_string_append_uri_escaped         (GString *string,
                                                         const char *unescaped,
                                                         const char *reserved_chars_allowed,
                                                         gboolean allow_utf8);
GString*            g_string_prepend                    (GString *string,
                                                         const gchar *val);
GString*            g_string_prepend_c                  (GString *string,
                                                         gchar c);
GString*            g_string_prepend_unichar            (GString *string,
                                                         gunichar wc);
GString*            g_string_prepend_len                (GString *string,
                                                         const gchar *val,
                                                         gssize len);
GString*            g_string_insert                     (GString *string,
                                                         gssize pos,
                                                         const gchar *val);
GString*            g_string_insert_c                   (GString *string,
                                                         gssize pos,
                                                         gchar c);
GString*            g_string_insert_unichar             (GString *string,
                                                         gssize pos,
                                                         gunichar wc);
GString*            g_string_insert_len                 (GString *string,
                                                         gssize pos,
                                                         const gchar *val,
                                                         gssize len);
GString*            g_string_overwrite                  (GString *string,
                                                         gsize pos,
                                                         const gchar *val);
GString*            g_string_overwrite_len              (GString *string,
                                                         gsize pos,
                                                         const gchar *val,
                                                         gssize len);
GString*            g_string_erase                      (GString *string,
                                                         gssize pos,
                                                         gssize len);
GString*            g_string_truncate                   (GString *string,
                                                         gsize len);
GString*            g_string_set_size                   (GString *string,
                                                         gsize len);
gchar*              g_string_free                       (GString *string,
                                                         gboolean free_segment);

GString*            g_string_up                         (GString *string);
GString*            g_string_down                       (GString *string);

guint               g_string_hash                       (const GString *str);
gboolean            g_string_equal                      (const GString *v,
                                                         const GString *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 <glib.h>

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;

}

运行结果：

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

andylauren

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Glib学习（5）字符串 Strings

先上说明文档网址：http://web.mit.edu/barnowl/share/gtk-doc/html/glib/glib-Strings.html学过面向对象语言的同学一定都知道String类，一定知道这个类对字符串的操作是多麽的方便，但是c语言中是没有这个类，甚至没有类的概念，但是glib帮我们做的这个“类” GString除了使用gchar *进行字符串处理以
复制链接

扫一扫