Chinaunix首页 | 论坛 | 博客
  • 博客访问: 2356783
  • 博文数量: 393
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 4178
  • 用 户 组: 普通用户
  • 注册时间: 2016-07-04 13:04
文章分类

全部博文(393)

文章存档

2020年(8)

2019年(24)

2018年(135)

2017年(158)

2016年(68)

我的朋友

分类: 嵌入式

2018-05-14 11:48:51


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


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

  1. #include   
  2.   
  3. int main(int argc,char **argv) {  
  4.   
  5. //    GString* g_string_new(const gchar *init);   根据所给的字符串建立适当长度的GString,并自动创建适当长度的allocated_len,创建的时候将字符串init复制到GString中。  
  6.     GString *string = g_string_new("Justin");  
  7.     g_print("g_string_new(\"Justin\"); len = %d, allocated_len = %d\n",   
  8.             string->len, string->allocated_len);  
  9.       
  10. //    若不使用GString时,可以使用g_string_free()释放,第二个参数如果为TRUE,会连同字符串也是放掉。  
  11.     g_string_free(string, TRUE);              
  12.   
  13. //    GString* g_string_new_len(const gchar *init, gssize len);     指定len来建立GString,因为是自行制定的长度,所以len必须超过init的长度。  
  14.     string = g_string_new_len("Justin", 32);  
  15.     g_print("g_string_new_len(\"Justin\", 32); len = %d, allocated_len = %d\n",   
  16.             string->len, string->allocated_len);      
  17.     g_string_free(string, TRUE);              
  18.   
  19. //    GString* g_string_sized_new(gsize dfl_size);      指定allocated_len建立GString,函数会根据需要的长度值自动分配长度,也就是不一定会分配设置的长度,但一定会比设定的长度大。  
  20.     string = g_string_sized_new(32);  
  21.     g_printf("g_string_sized_new(32); len = %d, allocated_len = %d\n",   
  22.             string->len, string->allocated_len);   
  23.     g_string_free(string, TRUE);     
  24.   
  25.   
  26.     GString *t=g_string_new("Hello Laomeng.");  
  27.     GString *s=g_string_new("Hello Laoli.");  
  28.       
  29. //    g_string_equal()    判断两个GString的字符串内容是否相同  
  30.     if(g_string_equal(s,t))   
  31.     {  
  32.         g_print("g_string_equal(s,t); %s  == %s\n",s->str,t->str);  
  33.     }   
  34.     else   
  35.     {  
  36.         g_print("g_string_equal(s,t); %s != %s\n",s->str,t->str);  
  37.     }  
  38.     g_string_free(s, TRUE);   
  39.     g_string_free(t, TRUE);   
  40.   
  41.     string = g_string_new("first str!");  
  42. //     GString* g_string_append (GString *string,const gchar *val);     在字符串string后面追加字符串val  
  43.     g_string_append(string, "second str!");  
  44.     g_print("g_string_append(string, \"second str!\"); %s\n", string->str);  
  45.   
  46. //    GString* g_string_truncate(GString *string,gsize len); 截断字符串,保留前len个字符  
  47.     g_string_truncate(string,5);  
  48.     g_print("g_string_truncate(string,5);  string:  %s, len = %d, allocated_len = %d\n",string->str, string->len , string->allocated_len);  
  49.   
  50. //     GString* g_string_prepend (GString *string,const gchar *val);     在字符串string前面追加字符串val  
  51.     g_string_prepend(string, "prepend str!");  
  52.     g_print("g_string_prepend(string, \"prepend str!\"); string:%s\n", string->str);  
  53.   
  54. //     GString* g_string_insert (GString *string,gssize pos,const gchar *val);     将字符串插入到pos处  
  55.     g_string_insert(string, sizeof("prepend str!")-1 , "insert str!");  
  56.     g_print("g_string_insert(string, sizeof(\"prepend str!\") , \"insert str!\"); %s\n", string->str);  
  57.   
  58. //    void g_string_printf(GString *string, const gchar *format, ...);  格式化一个字符串,和sprintf用法一样,只是赋值给一个GString,string里面以前的数据被销毁了  
  59.     g_string_printf(string,"%d + %d = %d", 100, 200, 100+200);  
  60.     g_print("g_string_printf(); GString: %s, len = %d, allocated_len = %d \n",string->str, string->len , string->allocated_len);  
  61.   
  62. //    void g_string_append_printf(GString *string, const gchar *format, ...);  格 式化一个字符串,和g_string_printf很相似,只是不销毁string里面的数据,而是在后面追加  
  63.     g_string_append_printf(string,"\t %d * %d = %d", 100,200,100*200);  
  64.     g_print("g_string_append_printf(); GString: %s, len = %d, allocated_len = %d \n",string->str, string->len , string->allocated_len);  
  65.   
  66.     g_string_free(string,TRUE);  
  67.   
  68.     string = g_string_new("abcdefgABCDEFG");  
  69.   
  70. //    g_string_ascii_up()或g_utf8_strup() 转换GString中的字符串为小写  
  71.     g_string_ascii_up(string);  
  72.     g_printf("Upper: %s\n", string->str);  
  73. //    g_string_ascii_down()或g_utf8_strdown()转换GString中的字符串为大写  
  74.     g_string_ascii_down(string);  
  75.     g_printf("Down: %s\n", string->str);  
  76.   
  77.     g_string_free(string,TRUE);  
  78.   
  79.     return 0;  
  80.   
  81. }  

运行结果:
[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$
阅读(783) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~