glib学习

glib概述

glibc 是gnu发布的libc库，也即c运行库，glib是gtk+的一套函数库,gobject是glib的精粹，glib是用C实现的.glib提供了动态数组、单/双向链表、哈希表、多叉树、平衡二叉树、字符串等常用容器，完全是面向对象设计的，实现得非常精致。

• 类型定义：

整数类型：gint8,guint8,gint16,guint16,gint32,guint32,gint64,guint64
整数类型:gshort,glong,gint和short,long,int等价

布尔类型：gboolean：TRUE FALSE

字符型：gfloat,gdouble与float、double等价

指针：gpointer相当于标准C的void *
gconstpointer相当于const void *

• glib宏

TRUE 1
FALSE 0
NULL (（void*）0)

MIN（） MAX（）返回最大或最小的数

ABS（）返回绝对值

CLAMP（x,low,high）若x在[low,high]返回内，则等于x，如果x小于low，则返回low；如果x大于high，则返回high

代码分析

1、打印hello word！

g_printf和printf函数基本一样用

gint g_printf (gchar const *format,...)

直接上代码

#include <stdio.h>
#include <glib.h>
 
int
main(int agrc, char **argv)
{
    g_printf("Hello world!\n");
 
    return 0;
}

这里主要是要表述glib库的头文件和动态链接库需要指定，pkg-config --cflags --libs glib-2.0可以输出指定的头文件和动态链接库

root@ubuntu:/code/test#gcc hello.c `pkg-config --cflags --libs glib-2.0`
root@ubuntu:/code/test#Hello world!

2、动态数组的使用

函数说明见代码注释

#include <glib.h>
#include <stdio.h>

void display_array(GArray *array, int len, const char *prompt)
{
    int i = 0;

    printf("%s: ", prompt);
    for (i = 0; i < len; i++) {
        printf("%d ", g_array_index(array, int, i));
    }
    printf("\n");
}

int main(int argc, char *argv[])
{
    GArray *array = NULL;
    int i = 0;
    int cur_arr_len = 0;
    int len = 0;

    array = g_array_new(FALSE, TRUE, sizeof(int));
    
    len = 0;
    for (i = 10; i < 15; i++) {
        g_array_append_val(array, i);   //从数组尾插入
        len++;
    }
    cur_arr_len += len;
    display_array(array, cur_arr_len, "Create array");

	int val = 9;
	g_array_prepend_val(array,val);//从数组头插入
	cur_arr_len += 1;
	display_array(array, cur_arr_len, "After prepend 9");


    int data = 100;
    g_array_insert_val(array, 5, data);//从数组下标索引插入
    cur_arr_len += 1;
    display_array(array, cur_arr_len, "After insert 100 at index 5");

    g_array_remove_index(array, 5);//删除数组下标索引对应的元素
    cur_arr_len -= 1;
    display_array(array, cur_arr_len, "After remove value at index 5");

    g_array_remove_index_fast(array, 3);
    cur_arr_len -= 1;
    display_array(array, cur_arr_len, "After remove value at index 3 fast");

    g_array_free(array, TRUE);//释放数组
}

编译运行结果

root@ubuntu:/code/test# gcc array.c `pkg-config --cflags --libs glib-2.0`
root@ubuntu:/code/test# ./a.out
Create array: 10 11 12 13 14
After prepend 9: 9 10 11 12 13 14
After insert 100 at index 5: 9 10 11 12 13 100 14
After remove value at index 5: 9 10 11 12 13 14
After remove value at index 3 fast: 9 10 11 14 13
root@ubuntu:/code/test#

3、String类型的使用

函数说明见代码注释

#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;
 
}

运行的结果

root@ubuntu:/code/test# gcc string.c `pkg-config --cflags --libs glib-2.0`
root@ubuntu:/code/test# ./a.out
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

4、线性表的使用

函数说明见代码注释

#include <glib.h>

static gint test_nums[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
static gint more_nums[10] = { 8, 9, 7, 0, 3, 2, 5, 1, 4, 6};

static gint
my_list_compare_one (gconstpointer a, gconstpointer b)
{
  gint one = *((const gint*)a);
  gint two = *((const gint*)b);
  return one-two;
}

static gint
my_list_compare_two (gconstpointer a, gconstpointer b)
{
  gint one = *((const gint*)a);
  gint two = *((const gint*)b);
  return two-one;
}


void my_list_print (gpointer       data,gpointer user_data)
{
	g_printf("%d \n",(*(gint*)data));
}


int
main(int agrc, char **argv)
{
  GList *list = NULL;
  guint i;

  for (i = 0; i < 10; i++)
    list = g_list_append (list, &test_nums[i]);//线性表从表尾追加
  list = g_list_reverse (list);//将线性表逆序

  for (i = 0; i < 10; i++)
    {
      GList *t = g_list_nth (list, i);//获取线性表索引的元素
      if (*((gint*) t->data) != (9 - i))
	g_error ("Regular insert failed");
	  else
	g_printf("*((gint*) t->data) = %d\n",*((gint*) t->data));
    }
  
  for (i = 0; i < 10; i++)
    if (g_list_position (list, g_list_nth (list, i)) != i)//查找线性表的元素对应的索引
      g_error ("g_list_position does not seem to be the inverse of g_list_nth");
	
  g_list_free (list);//释放线性表
  list = NULL;

  
  for (i = 0; i < 10; i++)
    list = g_list_insert_sorted (list, &more_nums[i], my_list_compare_one);//插入排序，排序顺序func函数决定

 
  g_printerr ("\n");
  g_list_foreach (list, my_list_print, NULL);//遍历所有的元素



  for (i = 0; i < 10; i++)
    {
      GList *t = g_list_nth (list, i);
      if (*((gint*) t->data) != i)
         g_error ("Sorted insert failed");
    }
	g_list_free (list);//释放线性表
	list = NULL;


	for (i = 0; i < 10; i++)
	  list = g_list_prepend (list, &more_nums[i]);//从头插入
	g_printerr ("g_list_prepend:\n");
	g_list_foreach (list, my_list_print, NULL);	
	
	list = g_list_sort (list, my_list_compare_two);//插入排序，排序顺序func函数决定
	
	
	g_printerr ("\n");
	g_list_foreach (list, my_list_print, NULL);
	
	g_list_free (list);//释放线性表
	list = NULL;  
    return 0;
}

运行结果

root@ubuntu:/code/test# gcc list.c `pkg-config --cflags --libs glib-2.0`
root@ubuntu:/code/test# ./a.out
*((gint*) t->data) = 9
*((gint*) t->data) = 8
*((gint*) t->data) = 7
*((gint*) t->data) = 6
*((gint*) t->data) = 5
*((gint*) t->data) = 4
*((gint*) t->data) = 3
*((gint*) t->data) = 2
*((gint*) t->data) = 1
*((gint*) t->data) = 0
g_list_insert_sorted:
0 1 2 3 4 5 6 7 8 9
g_list_prepend:
6 4 1 5 2 3 0 7 9 8
g_list_sort:
9 8 7 6 5 4 3 2 1 0
root@ubuntu:/code/test#