field1003

4_07_GLib库入门与实践_双链表

简介

在Glib中，链表有单向链表和双向链表两种，单向链表只有一个next指针，双向链表有prev和next两个指针。除非对程序的内存使用有非常严格的限制，一般情况下，尽量使用双向链表，这在查找、插入等操作时比单向链表方便很多。
单向链表的数据结构为GSList，双向链表的数据结构为GList，两者操作方式基本相同，只不过单向链表比双向链表少很多操作函数。

数据结构

单向链表数据结构

struct GSList {
  gpointer data;
  GSList *next;
};

双向链表数据结构

struct GList {
  gpointer data;
  GList *next;
  GList *prev;
};

函数列表

GList *	g_list_append ()
GList *	g_list_prepend ()
GList *	g_list_insert ()
GList *	g_list_insert_before ()
GList *	g_list_insert_sorted ()
GList *	g_list_remove ()
GList *	g_list_remove_link ()
GList *	g_list_delete_link ()
GList *	g_list_remove_all ()
void	g_list_free ()
void	g_list_free_full ()
GList *	g_list_alloc ()
void	g_list_free_1 ()
guint	g_list_length ()
GList *	g_list_copy ()
GList *	g_list_copy_deep ()
GList *	g_list_reverse ()
GList *	g_list_sort ()
gint	(*GCompareFunc) ()
GList *	g_list_insert_sorted_with_data ()
GList *	g_list_sort_with_data ()
gint	(*GCompareDataFunc) ()
GList *	g_list_concat ()
void	g_list_foreach ()
void	(*GFunc) ()
GList *	g_list_first ()
GList *	g_list_last ()
#define	g_list_previous()
#define	g_list_next()
GList *	g_list_nth ()
gpointer	g_list_nth_data ()
GList *	g_list_nth_prev ()
GList *	g_list_find ()
GList *	g_list_find_custom ()
gint	g_list_position ()
gint	g_list_index ()

函数功能分类

创建

GList

插入

GList * 	g_list_append ()
GList * 	g_list_prepend ()
GList * 	g_list_insert ()
GList * 	g_list_insert_before ()

逆序

GList * 	g_list_reverse ()

释放

void	g_list_free ()
void	g_list_free_full ()
void	g_list_free_1 ()

遍历

void 	g_list_foreach ()

测长

guint 	g_list_length ()

访问

GList * 	g_list_first ()
GList * 	g_list_last ()
#define 	g_list_previous()
#define 	g_list_next()

查找

GList * 	g_list_nth ()
gpointer 	g_list_nth_data ()
GList * 	g_list_nth_prev ()
gint 	g_list_position ()
gint 	g_list_index ()
GList * 	g_list_find ()
GList * 	g_list_find_custom ()

排序

GList * 	g_list_sort ()
GList * 	g_list_sort_with_data ()
GList * 	g_list_insert_sorted ()
GList * 	g_list_insert_sorted_with_data ()

删除

GList * 	g_list_remove ()
GList * 	g_list_remove_all ()
GList * 	g_list_remove_link ()
GList * 	g_list_delete_link ()

拼接

GList * 	g_list_concat ()

拷贝

GList * 	g_list_copy ()
GList * 	g_list_copy_deep ()

函数功能说明及综合演示

创建一个链表

GList没有专门创建链表的函数，只需要定义一个节点，即创建了链表。

GList *list;

节点插入

节点的插入有四个基本函数

GList * 	g_list_append ()
GList * 	g_list_prepend ()
GList * 	g_list_insert ()
GList * 	g_list_insert_before ()

节点释放

void	g_list_free () //释放所有节点
void	g_list_free_full () //释放所有节点，并指定私有数据的释放方式
void	g_list_free_1 () //释放一个节点，使用较少

下面来看一个节点插入及释放的例子。
源码见glib_examples\glib_list\glib_list_append_free

#include 

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *iter= NULL;

    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(5));

    for (iter = list; iter != NULL; iter = iter->next)
    {
        g_print("data is: %d \n", GPOINTER_TO_INT(iter->data));
    }

    g_list_free(list);

    return 0;
}

运行结果

data is: 1 
data is: 3 
data is: 5

分析：
首先创建一个空链表list，并插入三个整数，然后把链表的值全部打印出来，最后释放整个链表。使用valgrind工具检查一下是否有内存泄露。命令如下
valgrind --tool=memcheck --leak-check=full ./glib_list_append_free

[root@centos7_6 build]# valgrind --tool=memcheck --leak-check=full ./glib_list_append_free
==26247== Memcheck, a memory error detector
==26247== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==26247== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==26247== Command: ./glib_list_append_free
==26247== 
data is: 1 
data is: 3 
data is: 5 
==26247== 
==26247== HEAP SUMMARY:
==26247==     in use at exit: 2,214 bytes in 9 blocks
==26247==   total heap usage: 32 allocs, 23 frees, 102,209 bytes allocated
==26247== 
==26247== LEAK SUMMARY:
==26247==    definitely lost: 0 bytes in 0 blocks
==26247==    indirectly lost: 0 bytes in 0 blocks
==26247==      possibly lost: 0 bytes in 0 blocks
==26247==    still reachable: 2,214 bytes in 9 blocks
==26247==         suppressed: 0 bytes in 0 blocks
==26247== Reachable blocks (those to which a pointer was found) are not shown.
==26247== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==26247== 
==26247== For counts of detected and suppressed errors, rerun with: -v
==26247== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 f

可以看到，没有内存泄露。

链表遍历

上面介绍了一种链表的遍历方法，实际上，链表还有一个函数来专门进行元素遍历。

void
g_list_foreach (GList *list,
                GFunc func,
                gpointer user_data);

这个函数的第二个参数是一个函数指针，也就是常说的回调函数，用来指定如何遍历节点，这在GLib中是一种非常常见的用法，后面会经常见到。
第二个参数的指针函数原型如下：

void
(*GFunc) (gpointer data,
          gpointer user_data);

举例：可以实现如下回调函数，将结构体成员打印出来。

void _list_interger_print(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

这个回调函数的第一个参数data即是GList链表的data成员，第二个参数user_data是g_list_foreach的第三个参数，为回调函数的私有参数。下面程序演示使用g_list_foreach对链表进行遍历。
源码见glib_examples\glib_list\glib_list_foreach

#include 

void _list_interger_print(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
//    GList *iter= NULL;

    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(5));
    
//    for (iter = list; iter != NULL; iter = iter->next)
//    {
//        g_print("data is: %d \n", GPOINTER_TO_INT(iter->data));
//    }

    g_list_foreach(list, _list_interger_print, (gchar *)"");

    g_list_free(list);

    return 0;
}

运行结果如下：

data is: 1, user_data is: <user data> 
data is: 3, user_data is: <user data> 
data is: 5, user_data is: <user data>

链表插入

GLib为节点插入提供了四个函数：

GList * 	g_list_append ()
GList * 	g_list_prepend ()
GList * 	g_list_insert ()
GList * 	g_list_insert_before ()

第一个g_list_append前面已经介绍过了，此函数在大量插入节点时效率较低，原因是GList数据结构没有存储尾节点，因此在尾插时，只能先从头开始遍历，找到尾节点，再插入。在官方文档中介绍了一种常用的节点插入方法，即头插再逆序的方法，使用g_list_prepend插入所有节点，再使用g_list_reverse逆序。g_list_prepend的使用方法非常简单，与g_list_append几乎一模一样。
源码见glib_examples\glib_list\glib_list_prepend

#include 

void _list_interger_print(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;

    list = g_list_prepend(list, GINT_TO_POINTER(1));
    list = g_list_prepend(list, GINT_TO_POINTER(3));
    list = g_list_prepend(list, GINT_TO_POINTER(5));

    g_list_foreach(list, _list_interger_print, (gchar *)"");

    g_list_free(list);

    return 0;
}

运行结果：

data is: 5, user_data is: <user data> 
data is: 3, user_data is: <user data> 
data is: 1, user_data is: <user data>

对上述链表进行逆序。
源码见glib_examples\glib_list\glib_list_prepend_reverse

#include 

void _list_interger_print(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;

    list = g_list_prepend(list, GINT_TO_POINTER(1));
    list = g_list_prepend(list, GINT_TO_POINTER(3));
    list = g_list_prepend(list, GINT_TO_POINTER(5));

    list = g_list_reverse(list);

    g_list_foreach(list, _list_interger_print, (gchar *)"");

    g_list_free(list);

    return 0;
}

可以看到，头插再逆序的方法与尾插法结果相同。

data is: 1, user_data is: <user data> 
data is: 3, user_data is: <user data> 
data is: 5, user_data is: <user data>

接下来来看一下g_list_insert函数，其原型如下：

GList *
g_list_insert (GList *list,
               gpointer data,
               gint position);

第二个参数是要插入的数据，这个数据不需要包含prev和next指针的，链表自身会自动将节点补充完整。
第三个参数是插入的位置，从0开始，如果该值小于0或大于整个链表长度，则节点会被插入到链表尾。
链表插入举例：
源码见glib_examples\glib_list\glib_list_insert

#include 

void _list_interger_print(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;

    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(5));

    list = g_list_insert(list, GINT_TO_POINTER(2), 1);

    g_list_foreach(list, _list_interger_print, (gchar *)"");

    g_list_free(list);

    return 0;
}

运行结果：

data is: 1, user_data is: <user data> 
data is: 2, user_data is: <user data> 
data is: 3, user_data is: <user data> 
data is: 5, user_data is: <user data>

下面介绍另一种插入方法：g_list_insert_before函数和g_list_nth函数的组合。

GList *
g_list_insert_before (GList *list,
                      GList *sibling,
                      gpointer data);

第二个参数表示要在此节点之前插入data数据，很明显，需要先得到这个节点。
链表的访问和查找函数都可以得到一个具体的节点，g_list_nth可以根据下标得到链表中的某一节点。

GList *
g_list_nth (GList *list,
            guint n);

下面举例演示g_list_insert_before函数和g_list_nth函数的用法。
源码见glib_examples\glib_list\glib_list_insert_before

#include 

void _list_interger_print(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *l = NULL;

    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(5));

    list = g_list_insert(list, GINT_TO_POINTER(2), 1);


    g_list_foreach(list, _list_interger_print, (gchar *)"");

    l = g_list_nth(list, 3);
    list = g_list_insert_before(list, l, GINT_TO_POINTER(4));

    g_list_foreach(list, _list_interger_print, (gchar *)"");

    g_list_free(list);

    return 0;
}

运行结果：

data is: 1, user_data is: <before g_list_insert_before> 
data is: 2, user_data is: <before g_list_insert_before> 
data is: 3, user_data is: <before g_list_insert_before> 
data is: 5, user_data is: <before g_list_insert_before> 
data is: 1, user_data is: <after g_list_insert_before> 
data is: 2, user_data is: <after g_list_insert_before> 
data is: 3, user_data is: <after g_list_insert_before> 
data is: 4, user_data is: <after g_list_insert_before> 
data is: 5, user_data is: <after g_list_insert_before>

链表访问

链表有以下四个节点访问函数

GList * 	g_list_first ()
GList * 	g_list_last ()
#define 	g_list_previous()
#define 	g_list_next()

举例如下：
源码见glib_examples\glib_list\glib_list_access

#include 

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *l = NULL;
#if 1
    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(5));
    list = g_list_append(list, GINT_TO_POINTER(7));
#endif
    l = g_list_last(list);
    g_print("last element: %d \n", (NULL == l) ? 99999 : GPOINTER_TO_INT(l->data));

    l = g_list_previous(l);
    g_print("last->prev element: %d \n", (NULL == l) ? 99999 : GPOINTER_TO_INT(l->data));

    l = g_list_first(list);
    g_print("first element: %d \n", (NULL == l) ? 99999 : GPOINTER_TO_INT(l->data));

    l = g_list_next(l);
    g_print("first->next element: %d \n", (NULL == l) ? 99999 : GPOINTER_TO_INT(l->data));

    g_list_free(list);

    return 0;
}

运行结果：

last element: 7 
last->prev element: 5 
first element: 1 
first->next element: 3

链表查找

GList * 	g_list_nth ()
gpointer 	g_list_nth_data ()
GList * 	g_list_nth_prev ()
gint 	g_list_position ()
gint 	g_list_index ()
GList * 	g_list_find ()
GList * 	g_list_find_custom ()

//g_list_nth是查找里面最简单的一个函数，前面已经介绍过，传入下标，得到节点，注意下标以0开始。
GList *
g_list_nth (GList *list,
            guint n);

//g_list_nth_data与g_list_nth相仿，只不过g_list_nth返回节点，g_list_nth_data返回节点的值。
gpointer
g_list_nth_data (GList *list,
                 guint n);

//注意此函数：不是返回第n个节点的前一个节点，而是返回链表中某一节点的向前第n个节点，n为函数的第二个参数。
GList *
g_list_nth_prev (GList *list,
                 guint n);

//根据链表中的一个节点找到其在链表中的位置
gint
g_list_position (GList *list,
                 GList *llink);

//根据值找到节点在链表中的位置
gint
g_list_index (GList *list,
              gconstpointer data);

//根据节点的值找到节点。
GList *
g_list_find (GList *list,
             gconstpointer data);

//根据节点的值找到节点，但比较函数由用户自己实现。
//链表中的每一个节点，都会通过比较函数进行比较，若比较函数返回0，则代表节点已找到，//g_list_find_custom退出。
//本函数我们放到最后再讲。
GList *
g_list_find_custom (GList *list,
                    gconstpointer data,
                    GCompareFunc func);

下面是对查找函数的举例演示：
源码见glib_examples\glib_list\glib_list_find

#include 

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *l = NULL;
    gint n = 0;

    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(5));
    list = g_list_append(list, GINT_TO_POINTER(7));

    l = g_list_nth(list, 1);
    g_print("nth(list,1) element: %d \n", (NULL == l) ? 99999 : GPOINTER_TO_INT(l->data));

    n = GPOINTER_TO_INT(g_list_nth_data(list, 1));
    g_print("nth_data(list,1) element: %d \n", n);

    l = g_list_last(list);
    //7->5->3->1
    l = g_list_nth_prev(l, 3);
    g_print("nth_prev(last,3) element: %d \n", (NULL == l) ? 99999 : GPOINTER_TO_INT(l->data));

    l = g_list_last(list);
    n = g_list_position(list, l);
    g_print("last position: %d \n", n);

    n = g_list_index(list, GINT_TO_POINTER(5));
    g_print("element 5 position: %d \n", n);

    l = g_list_find(list, GINT_TO_POINTER(5));
    g_print("element 5 data: %d \n", (NULL == l) ? 99999 : GPOINTER_TO_INT(l->data));

    g_list_free(list);

    return 0;
}

运行结果：

nth(list,1) element: 3 
nth_data(list,1) element: 3 
nth_prev(last,2) element: 3 
last position: 3 
element 5 position: 2 
element 5 data: 5

可以看到，在GList中，节点以0为下标，即链表的第一个节点的下标为0。

链表排序

GList * 	g_list_sort ()
GList * 	g_list_sort_with_data ()
GList * 	g_list_insert_sorted ()
GList * 	g_list_insert_sorted_with_data ()

//链表排序，排序函数用户自己指定。
GList *
g_list_sort (GList *list,
             GCompareFunc compare_func);
//排序函数原型：
gint
(*GCompareFunc) (gconstpointer a,
                 gconstpointer b);
//排序函数返回值：negative value if a < b ; zero if a = b ; positive value if a > b；ab返回正值

//与g_list_sort功能相似，不过可以向比较函数传入用户数据。
GList *
g_list_sort_with_data (GList *list,
                       GCompareDataFunc compare_func,
                       gpointer user_data);

//插入一个数据data，其插入位置由比较函数决定。
//其实现方式为，先通过比较函数找到要插入的链表位置，再将数据插入链表。
//此处要求链表需要是有序的，如果原链表无序，此函数并不能实现插入数据后使链表变为有序状态的功能。
GList *
g_list_insert_sorted (GList *list,
                      gpointer data,
                      GCompareFunc func);

//与g_list_insert_sorted功能相似，不过可以向比较函数传入用户数据。
GList *
g_list_insert_sorted_with_data (GList *list,
                                gpointer data,
                                GCompareDataFunc func,
                                gpointer user_data);

下面是针对排序函数的演示程序。
源码见`glib_examples\glib_list\glib_list_sort

#include 

void _list_interger_print_func(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint _list_interger_cmp_func(gconstpointer a, gconstpointer b)
{
    return GPOINTER_TO_INT(a) - GPOINTER_TO_INT(b);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;

    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(5));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(7));

    g_list_foreach(list, _list_interger_print_func, (gchar *)"before insert_sorted");

    list = g_list_insert_sorted(list, GINT_TO_POINTER(4), _list_interger_cmp_func);

    g_list_foreach(list, _list_interger_print_func, (gchar *)"after insert_sorted");

    list = g_list_sort(list, _list_interger_cmp_func);

    g_list_foreach(list, _list_interger_print_func, (gchar *)"after sorted");

    g_list_free(list);

    return 0;
}

运行结果：

data is: 1, user_data is: before insert_sorted 
data is: 5, user_data is: before insert_sorted 
data is: 3, user_data is: before insert_sorted 
data is: 7, user_data is: before insert_sorted 
data is: 1, user_data is: after insert_sorted 
data is: 4, user_data is: after insert_sorted 
data is: 5, user_data is: after insert_sorted 
data is: 3, user_data is: after insert_sorted 
data is: 7, user_data is: after insert_sorted 
data is: 1, user_data is: after sorted 
data is: 3, user_data is: after sorted 
data is: 4, user_data is: after sorted 
data is: 5, user_data is: after sorted 
data is: 7, user_data is: after sorted

先调用g_list_insert_sorted，再调用g_list_sort，可以看出，当链表本身无序时，g_list_insert_sorted仅能在找到比自己大的数据后插入到其前面，并不能排序，而g_list_sort函数可以对链表进行排序。

链表删除

GList * 	g_list_remove ()
GList * 	g_list_remove_all ()
GList * 	g_list_remove_link ()
GList * 	g_list_delete_link ()

//删除链表中的节点，如果有多个相同的节点，则仅第一个被删除
GList *
g_list_remove (GList *list,
               gconstpointer data);

//删除链表中的节点，如果有多个相同的节点，则所有节点都会被删除
GList *
g_list_remove_all (GList *list,
                   gconstpointer data);

//将节点从链表移出，但并不释放该节点，返回的是一个自包含的链表，该链表的prev和next指针均为空。调用完本函数后，用户需要自己释放该节点，否则会造成内存泄露。
GList *
g_list_remove_link (GList *list,
                    GList *llink);

//删除节点，并且节点会被释放
GList *
g_list_delete_link (GList *list,
                    GList *link_);

节点删除功能演示：
源码见glib_examples\glib_list\glib_list_remove

#include 

void _list_interger_print_func(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *l = NULL;

    list = g_list_append(list, GINT_TO_POINTER(1));
    list = g_list_append(list, GINT_TO_POINTER(5));
    list = g_list_append(list, GINT_TO_POINTER(3));
    list = g_list_append(list, GINT_TO_POINTER(5));
    list = g_list_append(list, GINT_TO_POINTER(5));
    list = g_list_append(list, GINT_TO_POINTER(7));

    g_list_foreach(list, _list_interger_print_func, (gchar *)"original list");

    list = g_list_remove(list, GINT_TO_POINTER(5));

    g_list_foreach(list, _list_interger_print_func, (gchar *)"after remove 5");

    list = g_list_remove_all(list, GINT_TO_POINTER(5));

    g_list_foreach(list, _list_interger_print_func, (gchar *)"after remove_all 5");

    l = g_list_last(list);

    list = g_list_remove_link(list, l);

    g_list_free(l);

    l = g_list_first(list);

    list = g_list_delete_link(list, l);

    g_list_foreach(list, _list_interger_print_func, (gchar *)"after remove first and last");

    g_list_free(list);

    return 0;
}

运行结果：

data is: 1, user_data is: original list 
data is: 5, user_data is: original list 
data is: 3, user_data is: original list 
data is: 5, user_data is: original list 
data is: 5, user_data is: original list 
data is: 7, user_data is: original list 
data is: 1, user_data is: after remove 5 
data is: 3, user_data is: after remove 5 
data is: 5, user_data is: after remove 5 
data is: 5, user_data is: after remove 5 
data is: 7, user_data is: after remove 5 
data is: 1, user_data is: after remove_all 5 
data is: 3, user_data is: after remove_all 5 
data is: 7, user_data is: after remove_all 5 
data is: 3, user_data is: after remove first and last

屏蔽掉g_list_free(l);一行，使用valgrind工具，可以看到，如果不对g_list_remove_link移出的节点进行释放，会导致内存泄露。
valgrind --tool=memcheck --leak-check=full ./glib_list_remove

[root@centos7_6 build]# valgrind --tool=memcheck --leak-check=full ./glib_list_remove
==27844== Memcheck, a memory error detector
==27844== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==27844== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==27844== Command: ./glib_list_remove
==27844== 
data is: 1, user_data is: original list 
data is: 5, user_data is: original list 
data is: 3, user_data is: original list 
data is: 5, user_data is: original list 
data is: 5, user_data is: original list 
data is: 7, user_data is: original list 
data is: 1, user_data is: after remove 5 
data is: 3, user_data is: after remove 5 
data is: 5, user_data is: after remove 5 
data is: 5, user_data is: after remove 5 
data is: 7, user_data is: after remove 5 
data is: 1, user_data is: after remove_all 5 
data is: 3, user_data is: after remove_all 5 
data is: 7, user_data is: after remove_all 5 
data is: 3, user_data is: after remove first and last 
==27844== 
==27844== HEAP SUMMARY:
==27844==     in use at exit: 2,238 bytes in 10 blocks
==27844==   total heap usage: 107 allocs, 97 frees, 500,479 bytes allocated
==27844== 
==27844== 24 bytes in 1 blocks are definitely lost in loss record 6 of 10
==27844==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==27844==    by 0x4E856D0: g_malloc (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==27844==    by 0x4E9B2ED: g_slice_alloc (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==27844==    by 0x4E7C503: g_list_append (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==27844==    by 0x400B80: main (glib_list.c:18)
==27844== 
==27844== LEAK SUMMARY:
==27844==    definitely lost: 24 bytes in 1 blocks
==27844==    indirectly lost: 0 bytes in 0 blocks
==27844==      possibly lost: 0 bytes in 0 blocks
==27844==    still reachable: 2,214 bytes in 9 blocks
==27844==         suppressed: 0 bytes in 0 blocks
==27844== Reachable blocks (those to which a pointer was found) are not shown.
==27844== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==27844== 
==27844== For counts of detected and suppressed errors, rerun with: -v
==27844== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

链表拼接

GList * 	g_list_concat ()

拼接后，不可再释放第二个链表，举例：
源码见glib_examples\glib_list\glib_list_concat

#include 

void _list_interger_print_func(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list1 = NULL;
    GList *list2 = NULL;

    list1 = g_list_append(list1, GINT_TO_POINTER(1));
    list1 = g_list_append(list1, GINT_TO_POINTER(5));
    list2 = g_list_append(list2, GINT_TO_POINTER(3));
    list2 = g_list_append(list2, GINT_TO_POINTER(7));

    g_list_foreach(list1, _list_interger_print_func, (gchar *)"list1");
    g_list_foreach(list2, _list_interger_print_func, (gchar *)"list2");

    list1 = g_list_concat(list1, list2);
    g_list_foreach(list1, _list_interger_print_func, (gchar *)"list1-concat");
    g_list_foreach(list2, _list_interger_print_func, (gchar *)"list2-concat");

    g_list_free(list1);
    // g_list_free(list2);  //should not free list2

    return 0;
}

使用g_list_concat移动链表中的元素。
源码见glib_examples\glib_list\glib_list_move

#include 

void _list_interger_print_func(gpointer data, gpointer user_data)
{
    g_print("data is: %d, user_data is: %s \n", GPOINTER_TO_INT(data), (gchar *)user_data);
}

gint main(gint argc, gchar **argv)
{
    GList *list1 = NULL;
    GList *list2 = NULL;
    GList *l = NULL;

    list1 = g_list_append(list1, GINT_TO_POINTER(1));
    list1 = g_list_append(list1, GINT_TO_POINTER(5));
    list2 = g_list_append(list2, GINT_TO_POINTER(3));
    list2 = g_list_append(list2, GINT_TO_POINTER(7));


    g_list_foreach(list1, _list_interger_print_func, (gchar *)"list1");
    g_list_foreach(list2, _list_interger_print_func, (gchar *)"list2");

    g_print("===test concat=== \n");

    list1 = g_list_concat(list1, list2);
    g_list_foreach(list1, _list_interger_print_func, (gchar *)"list1-concat");
    g_list_foreach(list2, _list_interger_print_func, (gchar *)"list2-concat");

    g_print("===test move last to front=== \n");
    l = g_list_last(list1);
    list1 = g_list_remove_link(list1, l);
    list1 = g_list_concat(l, list1);

    g_list_foreach(list1, _list_interger_print_func, (gchar *)"list1-move-to-front");
    g_list_foreach(list2, _list_interger_print_func, (gchar *)"list2-move-to-front");

    g_list_free(list1);

    return 0;
}

运行结果：

data is: 1, user_data is: list1 
data is: 5, user_data is: list1 
data is: 3, user_data is: list2 
data is: 7, user_data is: list2 
===test concat=== 
data is: 1, user_data is: list1-concat 
data is: 5, user_data is: list1-concat 
data is: 3, user_data is: list1-concat 
data is: 7, user_data is: list1-concat 
data is: 3, user_data is: list2-concat 
data is: 7, user_data is: list2-concat 
===test move last to front=== 
data is: 7, user_data is: list1-move-to-front 
data is: 1, user_data is: list1-move-to-front 
data is: 5, user_data is: list1-move-to-front 
data is: 3, user_data is: list1-move-to-front 
data is: 3, user_data is: list2-move-to-front

链表拷贝

GList * 	g_list_copy ()
GList * 	g_list_copy_deep ()

举例
源码见glib_examples\glib_list\glib_list_deep_copy_err

#include 

void _list_str_print_func(gpointer data, gpointer user_data)
{
    g_print("user_data is: %s, data is: %s \n", (gchar *)user_data, (gchar*)data);
}

static gpointer _list_str_copy_deep (gconstpointer value, gpointer data)
{
  return (gpointer)g_strdup((const gchar *)value);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *list2 = NULL;
    GList *list3 = NULL;

    gchar str1[32] = {0};
    gchar str2[32] = {0};

    g_strlcpy(str1, "hello", sizeof("hello"));
    g_strlcpy(str2, "world", sizeof("world"));
    
    list = g_list_append(list, (gpointer)str1);
    list = g_list_append(list, (gpointer)str2);

    g_print("===test copy===\n");

    list2 = g_list_copy(list);

    g_list_foreach(list, _list_str_print_func, (gchar *)"list");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2");

    g_strlcpy(str2, "glib", sizeof("glib"));
    
    g_list_foreach(list, _list_str_print_func, (gchar *)"list-change");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2-change");

    g_print("===test deep copy===\n");

    list3 = g_list_copy_deep(list, _list_str_copy_deep, NULL);

    g_list_foreach(list, _list_str_print_func, (gchar *)"list");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2");
    g_list_foreach(list3, _list_str_print_func, (gchar *)"list3");

    g_strlcpy(str1, "welcome", sizeof("welcome"));

    g_list_foreach(list, _list_str_print_func, (gchar *)"list-deep-copy");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2-deep-copy");
    g_list_foreach(list3, _list_str_print_func, (gchar *)"list3-deep-copy");

    g_list_free(list);
    g_list_free(list2);
    g_list_free(list3);

    return 0;
}

运行结果：

===test copy===
user_data is: list, data is: hello 
user_data is: list, data is: world 
user_data is: list2, data is: hello 
user_data is: list2, data is: world 
user_data is: list-change, data is: hello 
user_data is: list-change, data is: glib 
user_data is: list2-change, data is: hello 
user_data is: list2-change, data is: glib 
===test deep copy===
user_data is: list, data is: hello 
user_data is: list, data is: glib 
user_data is: list2, data is: hello 
user_data is: list2, data is: glib 
user_data is: list3, data is: hello 
user_data is: list3, data is: glib 
user_data is: list-deep-copy, data is: welcome 
user_data is: list-deep-copy, data is: glib 
user_data is: list2-deep-copy, data is: welcome 
user_data is: list2-deep-copy, data is: glib 
user_data is: list3-deep-copy, data is: hello 
user_data is: list3-deep-copy, data is: glib

运行结果表明，g_list_copy类似于linux文件系统的符号链接，当链表内容有变化时，符号链接所指向的值也会变化。而g_list_copy_deep则不会受原链表内容变化的影响，因为g_list_copy_deep是对原链表的数值内存进行了拷贝。
上述代码有一处问题。
使用g_list_copy_deep得到了新链表，但未对新链表中使用g_strdup拷贝的节点主动释放，造成了内存泄露。使用valgrind进行检测，可以直观地看到内存泄露的地方。

[root@centos7_6 build]# valgrind --tool=memcheck --leak-check=full ./glib_list_deep_copy_err
==28540== Memcheck, a memory error detector
==28540== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==28540== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==28540== Command: ./glib_list_deep_copy_err
==28540== 
===test copy===
user_data is: list, data is: hello 
user_data is: list, data is: world 
user_data is: list2, data is: hello 
user_data is: list2, data is: world 
user_data is: list-change, data is: hello 
user_data is: list-change, data is: glib 
user_data is: list2-change, data is: hello 
user_data is: list2-change, data is: glib 
===test deep copy===
user_data is: list, data is: hello 
user_data is: list, data is: glib 
user_data is: list2, data is: hello 
user_data is: list2, data is: glib 
user_data is: list3, data is: hello 
user_data is: list3, data is: glib 
user_data is: list-deep-copy, data is: welcome 
user_data is: list-deep-copy, data is: glib 
user_data is: list2-deep-copy, data is: welcome 
user_data is: list2-deep-copy, data is: glib 
user_data is: list3-deep-copy, data is: hello 
user_data is: list3-deep-copy, data is: glib 
==28540== 
==28540== HEAP SUMMARY:
==28540==     in use at exit: 2,225 bytes in 11 blocks
==28540==   total heap usage: 151 allocs, 140 frees, 732,465 bytes allocated
==28540== 
==28540== 5 bytes in 1 blocks are definitely lost in loss record 3 of 11
==28540==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==28540==    by 0x4E856D0: g_malloc (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==28540==    by 0x4E9CBCE: g_strdup (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==28540==    by 0x400AB4: _list_str_copy_deep (glib_list_deep_copy_err.c:10)
==28540==    by 0x4E7C259: g_list_copy_deep (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==28540==    by 0x400C38: main (glib_list_deep_copy_err.c:42)
==28540== 
==28540== 6 bytes in 1 blocks are definitely lost in loss record 4 of 11
==28540==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==28540==    by 0x4E856D0: g_malloc (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==28540==    by 0x4E9CBCE: g_strdup (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==28540==    by 0x400AB4: _list_str_copy_deep (glib_list_deep_copy_err.c:10)
==28540==    by 0x4E7C22E: g_list_copy_deep (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==28540==    by 0x400C38: main (glib_list_deep_copy_err.c:42)
==28540== 
==28540== LEAK SUMMARY:
==28540==    definitely lost: 11 bytes in 2 blocks
==28540==    indirectly lost: 0 bytes in 0 blocks
==28540==      possibly lost: 0 bytes in 0 blocks
==28540==    still reachable: 2,214 bytes in 9 blocks
==28540==         suppressed: 0 bytes in 0 blocks
==28540== Reachable blocks (those to which a pointer was found) are not shown.
==28540== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==28540== 
==28540== For counts of detected and suppressed errors, rerun with: -v
==28540== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)

需要对在深拷贝时申请的内存进行释放。此处用到了链表释放函数g_list_free_full，本函数原型如下：

void
g_list_free_full (GList *list,
                  GDestroyNotify free_func);

本函数需要传入一个回调函数，提供每一个节点的释放方法。本函数对链表进行遍历，并根据提供的节点自定义释放方法对每一个节点进行释放。
源码见glib_examples\glib_list\glib_list_deep_copy

#include 

static void _list_str_print_func(gpointer data, gpointer user_data)
{
    g_print("user_data is: %s, data is: %s \n", (gchar *)user_data, (gchar*)data);
}

static gpointer _list_str_copy_deep (gconstpointer value, gpointer data)
{
  return (gpointer)g_strdup((const gchar *)value);
}

static void _list_str_copy_deep_free_func(gpointer data)
{
    g_free(data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *list2 = NULL;
    GList *list3 = NULL;

    gchar str1[32] = {0};
    gchar str2[32] = {0};

    g_strlcpy(str1, "hello", sizeof("hello"));
    g_strlcpy(str2, "world", sizeof("world"));
    
    list = g_list_append(list, (gpointer)str1);
    list = g_list_append(list, (gpointer)str2);

    g_print("===test copy===\n");

    list2 = g_list_copy(list);

    g_list_foreach(list, _list_str_print_func, (gchar *)"list");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2");

    g_strlcpy(str2, "glib", sizeof("glib"));
    
    g_list_foreach(list, _list_str_print_func, (gchar *)"list-change");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2-change");

    g_print("===test deep copy===\n");

    list3 = g_list_copy_deep(list, _list_str_copy_deep, NULL);

    g_list_foreach(list, _list_str_print_func, (gchar *)"list");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2");
    g_list_foreach(list3, _list_str_print_func, (gchar *)"list3");

    g_strlcpy(str1, "welcome", sizeof("welcome"));

    g_list_foreach(list, _list_str_print_func, (gchar *)"list-deep-copy");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2-deep-copy");
    g_list_foreach(list3, _list_str_print_func, (gchar *)"list3-deep-copy");

    g_list_free(list);
    g_list_free(list2);
    g_list_free_full(list3, _list_str_copy_deep_free_func);

    return 0;
}

再次使用valgrind检测，无内存泄露。

通过上面这个例子，可以得出结论：
GList只会开辟GList结构体的内存，即两个指针和一个指向实际数据的指针，不会为实际数据开辟内存，因此，如果想长期保存实际数据，则不可使用栈内存。如本例所示，若链表为全局变量，而str1,str2为局部变量，则函数运行结束时，str1和str2因为是局部变量而被释放，全局链表的值也变得未知。

链表浅拷贝要注意内存重复释放问题，见下面的例子：
源码见glib_examples\glib_list\glib_list_copy_err

#include 

static void _list_str_print_func(gpointer data, gpointer user_data)
{
    g_print("user_data is: %s, data is: %s \n", (gchar *)user_data, (gchar*)data);
}

static gpointer _list_str_copy_deep (gconstpointer value, gpointer data)
{
  return (gpointer)g_strdup((const gchar *)value);
}

static void _list_str_free_func(gpointer data)
{
    g_free((gchar *)data);
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *list2 = NULL;
    GList *list3 = NULL;

    gchar *str1 = NULL;
    gchar *str2 = NULL;

    str1 = g_strdup("hello");
    str2 = g_strdup("world");
    
    list = g_list_append(list, (gpointer)str1);
    list = g_list_append(list, (gpointer)str2);

    g_print("===test copy===\n");

    list2 = g_list_copy(list);

    g_list_foreach(list, _list_str_print_func, (gchar *)"list");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2");

    g_print("===test deep copy===\n");

    list3 = g_list_copy_deep(list, _list_str_copy_deep, NULL);

    g_list_foreach(list, _list_str_print_func, (gchar *)"list");
    g_list_foreach(list2, _list_str_print_func, (gchar *)"list2");
    g_list_foreach(list3, _list_str_print_func, (gchar *)"list3");

    g_list_free_full(list, _list_str_free_func);
    g_list_free(list2);  // #ERROR!!!:  g_list_free_full(list2, _list_str_free_func);
    g_list_free_full(list3, _list_str_free_func);

    return 0;
}

运行结果

===test copy===
user_data is: list, data is: hello 
user_data is: list, data is: world 
user_data is: list2, data is: hello 
user_data is: list2, data is: world 
===test deep copy===
user_data is: list, data is: hello 
user_data is: list, data is: world 
user_data is: list2, data is: hello 
user_data is: list2, data is: world 
user_data is: list3, data is: hello 
user_data is: list3, data is: world

上述例子看似正常，但使用valgrind检查，会发现内存问题，Invalid free()。

[root@centos7_6 build]# valgrind --tool=memcheck --leak-check=full ./glib_list_copy_err
==5414== Memcheck, a memory error detector
==5414== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==5414== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==5414== Command: ./glib_list_copy_err
==5414== 
===test copy===
user_data is: list, data is: hello 
user_data is: list, data is: world 
user_data is: list2, data is: hello 
user_data is: list2, data is: world 
===test deep copy===
user_data is: list, data is: hello 
user_data is: list, data is: world 
user_data is: list2, data is: hello 
user_data is: list2, data is: world 
user_data is: list3, data is: hello 
user_data is: list3, data is: world 
==5414== Invalid free() / delete / delete[] / realloc()
==5414==    at 0x4C2BDEC: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==5414==    by 0x400A2E: _list_str_free_func (glib_list_copy_err.c:15)
==5414==    by 0x4E7C657: g_list_foreach (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==5414==    by 0x4E7C67A: g_list_free_full (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==5414==    by 0x400B89: main (glib_list_copy_err.c:49)
==5414==  Address 0x5961040 is 0 bytes inside a block of size 6 free'd
==5414==    at 0x4C2BDEC: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==5414==    by 0x400A2E: _list_str_free_func (glib_list_copy_err.c:15)
==5414==    by 0x4E7C657: g_list_foreach (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==5414==    by 0x4E7C67A: g_list_free_full (in /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0)
==5414==    by 0x400B78: main (glib_list_copy_err.c:48)
==5414== 
==5414== 
==5414== HEAP SUMMARY:
==5414==     in use at exit: 2,214 bytes in 9 blocks
==5414==   total heap usage: 93 allocs, 86 frees, 400,768 bytes allocated
==5414== 
==5414== LEAK SUMMARY:
==5414==    definitely lost: 0 bytes in 0 blocks
==5414==    indirectly lost: 0 bytes in 0 blocks
==5414==      possibly lost: 0 bytes in 0 blocks
==5414==    still reachable: 2,214 bytes in 9 blocks
==5414==         suppressed: 0 bytes in 0 blocks
==5414== Reachable blocks (those to which a pointer was found) are not shown.
==5414== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==5414== 
==5414== For counts of detected and suppressed errors, rerun with: -v
==5414== ERROR SUMMARY: 2 errors from 1 contexts (suppressed: 0 from 0)

原因是list2是浅拷贝过来的，只需要释放链表自身，不需要释放其中的每个节点。如果查看g_list_copy的源码，可以发现list2的每一个节点都是动态申请的新内存，但其中的三个指针(prev,next,data)均指向list节点，并未开辟新的内存。因此，在函数结束时，只需要释放list2的每一个节点，也就是GList结构体的三个指针自身所占的内存，释放list2并不影响list，list的值仍存在。
将g_list_free_full(list2, _list_str_free_func);改为g_list_free(list2);即可消除内存错误。

用户自定义数据

如果是用户自定义的数据，又该如何使用上面的函数呢？
首先定义一个结构体，里面存的是公司员工工号和姓名。

typedef struct employee_info_tag {
    gint id;
    gchar *name;
}employee_info_t;

员工工号int型就够了，由于员工姓名有长有短，所以这里使用指针来存储不定长度的员工姓名。下面演示插入四个员工信息到链表。
源码见glib_examples\glib_list\glib_list_custom_data_insert

#include 

typedef struct employee_info_tag {
    gint id;
    gchar *name;
}employee_info_t;

static void _list_struct_print_func(gpointer data, gpointer user_data)
{
    employee_info_t *einfo = NULL;

    einfo = (employee_info_t *)data;
    if(NULL == einfo) {
        g_print("input param error! \n");
        return;
    }

    g_print("user_data:%s, einfo->id:%d, einfo->name:%s \n", (gchar *)user_data, einfo->id, einfo->name);
}

static void _list_struct_free_func(gpointer data)
{
    employee_info_t *einfo = NULL;

    einfo = (employee_info_t *)data;

    if( (NULL != einfo) && (NULL != einfo->name) ) {
        g_free(einfo->name);
    }

    if(NULL != einfo) {
        g_free(einfo);
    }
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *l = NULL;

    employee_info_t *einfo[4] = {NULL, NULL, NULL, NULL};

    einfo[0] = g_new0(employee_info_t, 1);
    einfo[1] = g_new0(employee_info_t, 1);
    einfo[2] = g_new0(employee_info_t, 1);
    einfo[3] = g_new0(employee_info_t, 1);

    einfo[0]->id = 1000;
    einfo[0]->name = g_strdup("Jack");
    einfo[1]->id = 1001;
    einfo[1]->name = g_strdup("Pony");
    einfo[2]->id = 1002;
    einfo[2]->name = g_strdup("Robin");
    einfo[3]->id = 1003;
    einfo[3]->name = g_strdup("NoName");

    list = g_list_append(list, (gpointer)einfo[0]); //Jack
    list = g_list_prepend(list, (gpointer)einfo[1]); //Pony->Jack
    list = g_list_insert(list, (gpointer)einfo[2], 1); //Pony->Robin->Jack

    l = g_list_nth(list, 0);
    list = g_list_insert_before(list, l, (gpointer)einfo[3]); //NoName->Pony->Robin->Jack

    g_list_foreach(list, _list_struct_print_func, "GList");

    g_list_free_full(list, _list_struct_free_func);

    return 0;
}

运行结果：

user_data:GList, einfo->id:1003, einfo->name:NoName 
user_data:GList, einfo->id:1001, einfo->name:Pony 
user_data:GList, einfo->id:1002, einfo->name:Robin 
user_data:GList, einfo->id:1000, einfo->name:Jack

下面重点分析一下上面链表的内存创建和释放过程。
（请将下面几行逐行复制到文本编辑器并调整字体为等宽字体如宋体、Courier New等再查看。）

Node1*<---->Node2*<---->Node3*<---->Node4*
 ├prev       ├prev       ├prev       ├prev
 ├next       ├next       ├next       ├next
 └data*      └data*      └data*      └data*
   └einfo[0]   └einfo[1]   └einfo[2]   └einfo[3]
     ├id(1003)   ├id(1001)   ├id(1002)   ├id(1000)
     └name*      └name*      └name*      └name*

上述链表的每个节点都由三部分内存构成，以Node1为例。

第一部分是Node1节点的内存，包括prev，next和data三个指针，这些内存在调用append/prepend/insert时创建，在调用g_list_free时被释放；
第二部分是data所指向的数据，即einfo[0]，这部分内存在g_new0创建，在g_list_free_full的自定义释放函数中释放，即g_free(einfo)语句；
第三部分是name所指向的数据，这部分存的是如Pony、Robin、Jack之类的员工姓名，通过g_strdup()创建，在g_list_free_full的自定义释放函数中释放，g_free(einfo->name)；

上述三部分内存的释放顺序为，先释放name，再释放einfo[0]，最后释放Node1，其余节点也按照这个顺序释放，直至整个链表销毁。

由于使用了自定义数据，在操作链表（排序、查找、深拷贝）时，就会用到很多自定义函数，如下所示。

g_list_sort
g_list_find_custom
g_list_copy_deep

下面举例演示。
源码见glib_examples\glib_list\glib_list_custom_data_ops

#include 

typedef struct employee_info_tag {
    gint id;
    gchar *name;
}employee_info_t;

static void _list_struct_print_func(gpointer data, gpointer user_data)
{
    employee_info_t *einfo = NULL;

    einfo = (employee_info_t *)data;
    if(NULL == einfo) {
        g_print("input param error! \n");
        return;
    }

    g_print("user_data:%s, einfo->id:%d, einfo->name:%s \n", (gchar *)user_data, einfo->id, einfo->name);
}

static void _list_struct_free_func(gpointer data)
{
    employee_info_t *einfo = NULL;

    einfo = (employee_info_t *)data;

    if( (NULL != einfo) && (NULL != einfo->name) ) {
        g_free(einfo->name);
    }

    if(NULL != einfo) {
        g_free(einfo);
    }
}

static gint _list_struct_name_cmp_func(gconstpointer a, gconstpointer b)
{
    employee_info_t *einfo_a = NULL;
    employee_info_t *einfo_b = NULL;

    einfo_a = (employee_info_t *)a;
    einfo_b = (employee_info_t *)b;

    if( (NULL == einfo_a) || (NULL == einfo_b) ) {
        g_print("input param error! \n");
        return 0;
    }

    return g_strcmp0(einfo_a->name, einfo_b->name);
}

static gint _list_struct_id_cmp_func(gconstpointer a, gconstpointer b)
{
    employee_info_t *einfo_a = NULL;
    employee_info_t *einfo_b = NULL;

    einfo_a = (employee_info_t *)a;
    einfo_b = (employee_info_t *)b;

    if( (NULL == einfo_a) || (NULL == einfo_b) ) {
        g_print("input param error! \n");
        return 0;
    }

    return (einfo_a->id - einfo_b->id);
}

static gint _list_struct_id_find_func(gconstpointer a, gconstpointer b)
{
    employee_info_t *einfo_a = NULL;
    gint id;

    einfo_a = (employee_info_t *)a;
    id = GPOINTER_TO_INT(b);

    if (NULL == einfo_a) {
        g_print("input param error! \n");
        return 0;
    }

    return (einfo_a->id - id);
}

static gint _list_struct_name_find_func(gconstpointer a, gconstpointer b)
{
    employee_info_t *einfo_a = NULL;
    gchar *name = NULL;

    einfo_a = (employee_info_t *)a;
    name = (gchar *)b;

    if (NULL == einfo_a) {
        g_print("input param error! \n");
        return 0;
    }

    return g_strcmp0(einfo_a->name, name);
}

static gpointer _list_struct_copy_func(gconstpointer src, gpointer data)
{
    employee_info_t *einfo = NULL;

    einfo = g_new0(employee_info_t, 1);

    einfo->id = ((employee_info_t *)src)->id + GPOINTER_TO_INT(data);
    einfo->name = g_strdup(((employee_info_t *)src)->name);

    return (gpointer)einfo;
}

gint main(gint argc, gchar **argv)
{
    GList *list = NULL;
    GList *l = NULL;
    GList *list2 = NULL;

    employee_info_t *einfo[4] = {NULL, NULL, NULL, NULL};

    einfo[0] = g_new0(employee_info_t, 1);
    einfo[1] = g_new0(employee_info_t, 1);
    einfo[2] = g_new0(employee_info_t, 1);
    einfo[3] = g_new0(employee_info_t, 1);

    einfo[0]->id = 1000;
    einfo[0]->name = g_strdup("Jack");
    einfo[1]->id = 1001;
    einfo[1]->name = g_strdup("Pony");
    einfo[2]->id = 1002;
    einfo[2]->name = g_strdup("Robin");
    einfo[3]->id = 1003;
    einfo[3]->name = g_strdup("NoName");

    list = g_list_append(list, (gpointer)einfo[0]); //Jack
    list = g_list_prepend(list, (gpointer)einfo[1]); //Pony->Jack
    list = g_list_insert(list, (gpointer)einfo[2], 1); //Pony->Robin->Jack

    l = g_list_nth(list, 0);
    list = g_list_insert_before(list, l, (gpointer)einfo[3]); //NoName->Pony->Robin->Jack

    g_list_foreach(list, _list_struct_print_func, "ori");

    // #sort
    list = g_list_sort(list, _list_struct_id_cmp_func);

    g_list_foreach(list, _list_struct_print_func, "id sort");

    list = g_list_sort(list, _list_struct_name_cmp_func);

    g_list_foreach(list, _list_struct_print_func, "name sort");

    // #find
    l = g_list_find_custom(list, GINT_TO_POINTER(1002), _list_struct_id_find_func);
    if( NULL != l) {
        g_print("found by id! id=%d, name=%s \n", ((employee_info_t *)l->data)->id, ((employee_info_t *)l->data)->name);
    } else {
        g_print("can not found by id! \n");
    }

    l = g_list_find_custom(list, (gpointer)"Jack", _list_struct_name_find_func);
    if( NULL != l) {
        g_print("found by name! id=%d, name=%s \n", ((employee_info_t *)l->data)->id, ((employee_info_t *)l->data)->name);
    } else {
        g_print("cat not found by name! \n");
    }

    // #copy
    list2 = g_list_copy_deep(list, _list_struct_copy_func, GINT_TO_POINTER(5000));

    g_list_foreach(list2, _list_struct_print_func, "list2");
    g_list_free_full(list2, _list_struct_free_func);

    g_list_free_full(list, _list_struct_free_func);

    return 0;
}

运行结果：

user_data:ori, einfo->id:1003, einfo->name:NoName 
user_data:ori, einfo->id:1001, einfo->name:Pony 
user_data:ori, einfo->id:1002, einfo->name:Robin 
user_data:ori, einfo->id:1000, einfo->name:Jack 
user_data:id sort, einfo->id:1000, einfo->name:Jack 
user_data:id sort, einfo->id:1001, einfo->name:Pony 
user_data:id sort, einfo->id:1002, einfo->name:Robin 
user_data:id sort, einfo->id:1003, einfo->name:NoName 
user_data:name sort, einfo->id:1000, einfo->name:Jack 
user_data:name sort, einfo->id:1003, einfo->name:NoName 
user_data:name sort, einfo->id:1001, einfo->name:Pony 
user_data:name sort, einfo->id:1002, einfo->name:Robin 
found by id! id=1002, name=Robin 
found by name! id=1000, name=Jack 
user_data:list2, einfo->id:6000, einfo->name:Jack 
user_data:list2, einfo->id:6003, einfo->name:NoName 
user_data:list2, einfo->id:6001, einfo->name:Pony 
user_data:list2, einfo->id:6002, einfo->name:Robin

分析：
创建一个带有自定义节点的链表，先根据员工工号进行排序，再根据员工姓名进行排序，再通过员工工号进行查找，再通过员工姓名进行查找，最后深拷贝一个链表，同时把链表中的所有员工工号增加5000。

思考：
如果上述数据结构，name不是一个字符串指针，而是一个固定长度的数组呢？比name是指针处理起来复杂还是简单，如何实现？

typedef struct employee_info_tag {
    gint id;
    gchar name[32];
}employee_info_t;

专题

浅谈链表的内存空间

前面在讲链表拷贝时提到链表中的节点不能是局部变量，那么如果是局部变量，会导致什么后果呢，下面通过例子演示一下效果。
源码见glib_examples\glib_list\glib_list_mem

#include 

GList *global_list = NULL;

static void _list_str_print_func(gpointer data, gpointer user_data)
{
    g_print("user_data is: %s, data is: %s \n", (gchar *)user_data, (gchar*)data);
}

static void _list_local_var_str_append(void)
{
    gchar str1[32] = {0};
    gchar str2[32] = {0};

    g_strlcpy(str1, "hello", sizeof("hello"));
    g_strlcpy(str2, "world", sizeof("world"));

    global_list = g_list_append(global_list, (gpointer)str1);
    global_list = g_list_append(global_list, (gpointer)str2);
}

static void _list_const_var_str_append(void)
{
    gchar *str1 = "hello";
    gchar *str2 = "world";

    global_list = g_list_append(global_list, (gpointer)str1);
    global_list = g_list_append(global_list, (gpointer)str2);
}

static void _list_heap_var_str_append(void)
{
    gchar *str1 = g_strdup("hello");
    gchar *str2 = g_strdup("world");

    global_list = g_list_append(global_list, (gpointer)str1);
    global_list = g_list_append(global_list, (gpointer)str2);
}

static void _list_heap_var_str_free_func(gpointer data)
{
    g_free((gchar *)data);
}

gint main(gint argc, gchar **argv)
{

    _list_local_var_str_append();
    g_list_foreach(global_list, _list_str_print_func, "local var");
    g_list_free(global_list);
    global_list = NULL;

    _list_const_var_str_append();
    g_list_foreach(global_list, _list_str_print_func, "const var");
    g_list_free(global_list);
    global_list = NULL;

    _list_heap_var_str_append();
    g_list_foreach(global_list, _list_str_print_func, "heap var");
    g_list_free_full(global_list, _list_heap_var_str_free_func);
    global_list = NULL;

    return 0;
}

运行结果：

[Invalid UTF-8] user_data is: local var, data is:  \xee\xf2 
[Invalid UTF-8] user_data is: local var, data is: \xa4\x0d@ 
user_data is: const var, data is: hello 
user_data is: const var, data is: world 
user_data is: heap var, data is: hello 
user_data is: heap var, data is: world

分析：在栈(局部变量)、静态存储区(字符串)和堆(malloc申请)上分别申请内存，并将这三种内存类型的数据加入链表。结合上面的运行结果，可以得出如下结论：

在栈上分配的内存，加入链表后，无法打印出来，原因是_list_local_var_str_append函数调用结束，str1和str2这两个局部变量已经被释放掉了。
在静态存储区的字符串，在函数调用结束时，不会被释放。
存储在堆内存上的字符串，只能靠用户手动释放，因此需要调用g_list_free_full对节点的值进行释放，否则就会造成内存泄露。

你可能感兴趣的:(GLib库入门与实践,链表,list,数据结构,GLib,c语言)

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
随笔 | 仙一般的灵气海思沧海
仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
mysql禁用远程登录 igotyback mysql
去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
2021-08-26 影幽
在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
高级编程--XML+socket练习题 masa010 java 开发语言
1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
每日一题——第九十题互联网打工人no1 C语言程序设计每日一练 c语言
题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
WPF中的ComboBox控件几种数据绑定的方式互联网打工人no1 wpf c#
一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
《庄子.达生9》钱江潮369
【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
水泥质量纠纷案代理词徐宝峰律师
贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
第四天旅游线路预览——从换乘中心到喀纳斯湖陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
ios内付费 374016526 ios 内付费
近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。具体使用如下: 这里的sender其实就是调用者，这里主要是为了回调使用。 [KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
20 款优秀的 Linux 终端仿真器 brotherlamp linux linux视频 linux资料 linux自学 linux教程
终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。）你能从开源世界中找到大量的终端仿真器，它们
Solr Deep Paging(solr 深分页) eksliang solr深分页 solr分页性能问题
转载请出自出处：http://eksliang.iteye.com/blog/2148370 作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
数据库面试题 18289753290 面试题数据库
1.union ,union all 网络搜索出的最佳答案： union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。 Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序； Union All：对两个结果集进行并集操作，包括重复行，不进行排序； 2.索引有哪些分类？作用是
Android TV屏幕适配酷的飞上天空 android
先说下现在市面上TV分辨率的大概情况两种分辨率为主 1.720标清，分辨率为1280x720. 屏幕尺寸以32寸为主，部分电视为42寸 2.1080p全高清，分辨率为1920x1080 屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有适配遇到问题，已1080p尺寸为例：分辨率固定不变，屏幕尺寸变化较大。如：效果图尺寸为1920x1080，如果使用d
Timer定时器与ActionListener联合应用永夜-极光 java
功能:在控制台每秒输出一次代码: package Main; import javax.swing.Timer; import java.awt.event.*; public class T { private static int count = 0; public static void main(String[] args){
Ubuntu14.04系统Tab键不能自动补全问题解决随便小屋 Ubuntu 14.04
Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下： 1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限） sudo vi /etc/bash.bashrc 接下来会提示输入密码 2、找到文件中的下列代码 #enable bash completion in interactive shells #if
学会人际关系三招轻松走职场 aijuans 职场
要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。　　第一，多汇报最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。　　第二，勤沟通团队的力
《O2O：移动互联网时代的商业革命》读书笔记 aoyouzi 读书笔记
移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。 O2O：Online to OffLine 线上线下活动 O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
js实现图片随鼠标滚动的效果百合不是茶 JavaScript 滚动属性的获取图片滚动属性获取页面加载
1,获取样式属性值 top 与顶部的距离 left 与左边的距离 right 与右边的距离 bottom 与下边的距离 zIndex 层叠层次例子:获取左边的宽度,当css写在body标签中时 <div id="adver" style="position:absolute;top:50px;left:1000p
ajax同步异步参数async bijian1013 jquery Ajax async
开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。格式： $.ajax({ type: 'POST', ur
Webx3框架（1） Bill_chen eclipse spring maven 框架 ibatis
Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发；采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。 Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
【MongoDB学习笔记五】MongoDB概述 bit1129 mongodb
MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
spring/hibernate/struts2常见异常总结白糖_ Hibernate
Spring ①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException 缺少aspectjweaver.jar，该jar包常用于spring aop中 ②java.lang.ClassNotFoundException: org.sprin
jquery easyui表单重置(reset)扩展思路 bozch form jquery easyui reset
在jquery easyui表单中尚未提供表单重置的功能，这就需要自己对其进行扩展。扩展的时候要考虑的控件有： combo,combobox,combogrid,combotree,datebox,datetimebox 需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。在所有的reset方法添加完毕之后，就需要对fo
编程之美-烙饼排序 bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; /* *《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。 *《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码： */
Struts1.X 源码分析之ActionForm赋值原理 chenbowen00 struts
struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
[空天防御与经济]在获得充足的外部资源之前,太空投资需有限度 comsci 资源
这里有一个常识性的问题: 地球的资源,人类的资金是有限的,而太空是无限的..... 就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制.... &
ORACLE临时表—ON COMMIT PRESERVE ROWS daizj oracle 临时表
ORACLE临时表转临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
基于Nginx XSendfile+SpringMVC进行文件下载 denger 应用服务器 Web nginx 网络应用 lighttpd
在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。 @RequestMapping("/courseware/{id}") public void download(@PathVariable("id") String courseID, HttpServletResp
scanf接受char类型的字符 dcj3sjt126com c
/* 2013年3月11日22:35:54 目的：学习char只接受一个字符 */ # include <stdio.h> int main(void) { int i; char ch; scanf("%d", &i); printf("i = %d\n", i); scanf("%
学编程的价值 dcj3sjt126com 编程
发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助像这位朋友学习: http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
二维数组（矩阵）对角线输出飞天奔月二维数组
今天在BBS里面看到这样的面试题目, 1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组 { 1 2 3 4 } { 5 6 7 8 } { 9 10 11 12 } {13 14 15 16 } 打印顺序 4 3 8 2 7 12 1 6 11 16 5 10 15 9 14 13 要
Ehcache（08）——可阻塞的Cache——BlockingCache 234390216 并发 ehcache BlockingCache 阻塞
可阻塞的Cache—BlockingCache 在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
mysqldiff对数据库间进行差异比较 jackyrong mysqld
mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下： 1）基本用法 mysqldiff --server1=admin:12345
spring data jpa 方法中可用的关键字 lawrence.li java spring
spring data jpa 支持以方法名进行查询/删除/统计。查询的关键字为find 删除的关键字为delete/remove (>=1.7.x) 统计的关键字为count (>=1.7.x) 修改需要使用@Modifying注解 @Modifying @Query("update User u set u.firstna
Spring的ModelAndView类 nicegege spring
项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？ /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * yo
搭建 CentOS 6 服务器(13) - rsync、Amanda rensanning centos
（一）rsync Server端 # yum install rsync # vi /etc/xinetd.d/rsync service rsync { disable = no flags = IPv6 socket_type = stream wait
Learn Nodejs 02 toknowme nodejs
（1）npm是什么 npm is the package manager for node 官方网站：https://www.npmjs.com/ npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用 &nb
Spring MVC 拦截器 xp9802 spring mvc
Controller层的拦截器继承于HandlerInterceptorAdapter HandlerInterceptorAdapter.java 1 public abstract class HandlerInterceptorAdapter implements HandlerIntercep