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语言)

redis之源码包安装瀟湘夜雨-秋雨梧桐 redis 数据库缓存
文章目录前言一、安装步骤1.源码包官方下载2.解压源码包3.安装redis4.配置环境变量5.redis服务启动前言Redis（RemoteDictionaryServer）是一个开源的高性能内存数据存储系统。它以键值对的形式存储数据，并支持多种数据结构，如字符串、哈希表、列表、集合和有序集合等。Redis具有低延迟、高吞吐量的特点，适用于对响应时间要求较高的场景。它支持数据持久化，通过快照和日志
Deep learning for Computer Vision with Python（1）从零开始入门计算机视觉 Hazelyu27 计算机视觉大数据计算机视觉深度学习
本书的内容分成三个部分：1.初始阶段初始阶段学习：机器学习、神经网络、卷积神经网络、建立数据集。2.实践阶段实践阶段：深入学习深度学习，理解先进技术，发现最佳实践方式。3.图像网络阶段完成计算机视觉领域的经验积累。使用大规模数据集和真实图片案例作为数据集，包括年龄和性别预测，交通工具模型识别。本书提供了对应网站：http://pyimg.co/fnkxk本文介绍前两章内容：基本介绍和深度学习简介。
Java中的分布式计算：如何在多节点环境中实现高效计算省赚客app开发者 java 开发语言
Java中的分布式计算：如何在多节点环境中实现高效计算大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在现代计算中，分布式计算已成为处理大量数据和复杂计算任务的标准解决方案。通过将计算任务分散到多个节点上，可以显著提升计算性能和系统的可扩展性。本文将探讨如何在Java环境中实现高效的分布式计算，涵盖从基本概念到具体的技术实现和最佳实践。一、分布式计算基础分布式计算指的
实训day4 yolo1代码运行 Hazelyu27
yolo1代码运行今天主要是在pycharm上运行pytorch的yolo1训练和测试代码。主要遇到的问题：1.训练文件路径的修改，开始没有找到tmp_file文件，就在该文件夹下创建了这个txt文件，但是发现：ifisinstance(list_file,list):#Catmultiplelistfilestogether.#Thisisespeciallyusefulforvoc07/voc
大模型LLM面试常见算法题-包括Attention和Transformer常见面试题剑圣土豆算法面试大模型学习自然语言处理 transformer 算法 nlp 自然语言处理面试深度学习人工智能
大模型：位置编码有哪些？介绍LoRA与QLoRARAG和微调的区别是什么？哪些因素会导致LLM的偏见？什么是思维链（CoT）提示？Tokenizer的实现方法及原理解释一下大模型的涌现能力？解释langchainAgent的概念langchain有哪些替代方案？RLHF完整训练过程是什么？为什么RLHF的效果这么好?RLHF使用的训练数据是什么样的?RAG和微调的区别是什么？有了解过什么是稀疏微调
用python的NiceGUI库实现webApp___官网文档熟悉错误重复学习记录 web app
官网文档文本元素ui.label、、ui.markdown和ui.restructured_text等元素ui.html可用于显示文本和其他内容。TextElementsLabel、Link、ChatMessage、GenericElement、MarkdownElement、ReStructuredText、MermaidDiagrams、HTMLElement控制NiceGUI提供了多种用于用
linuxcnc-cia402 README 错误重复学习记录笔记
hal-cia402CiA402器件的HAL接口，该组件用作硬件与Hal模块（如Ethercat、CAN总线或其他）之间的粘合层。它将原始IO数据从PDO转换为常见的linuxcncHal引脚结构，并具有内置逻辑用于CiA402状态控制、反馈处理、外部归位和内置缩放功能。它提供两个函数：read_all和write_all。相应任务中的整合概念应如下：硬件输入-->--CiA402_read-->
全面从严治党，树好党政标杆 HN丶
近日，中共中央办公厅印发了《党委(党组)落实全面从严治党主体责任规定》，《规定》中明确了主体责任内容，要求地方党委(党组)应当坚持党建工作与业务工作同谋划、同部署、同推进、同考核，加强对本单位全面从严治党各项工作的领导，树好党政标杆。从严落实思想建党，党员干部要认真学习党章、严格遵守党章，以党章为武器加强党性修养。必须始终牢记入党誓言，以焦裕禄、杨善洲等模范人物为榜样，对照宗旨查摆自身存在的问题并
吴春燕|将儿童读写进行到底燕然然
经过一段时间的学习，今天获得了担当者行动橡果书院“儿童阅读指导师初级认证证书”，其课程内容对应的是书籍《儿童读写三十讲》的精华内容。经过书籍精华的淬炼、梳理与打磨，课程分三十讲细致地谈及读写的方方面面。听完课对书籍所表达的理念更加理解了。魏智渊的《儿童读写三十讲》真是一本充满智慧的宝藏书籍。序言讲的是核心素养背景下的儿童阅读，在最后梳理了人生不同阅读的重点和状态，这个值得我们关注。小学阅读的关键，
2018-02-21 山奈_4f40
“诸多人生况味中非常重要的一项就是异乡体验与故乡意识的深刻交糅，漂泊欲念与回归意识的相辅相成。”某一年在绿皮火车上读余秋雨，对这句话感慨良多。那一年我还在北京读书，在朋友圈写到：“相比余秋雨的阅历，年轻人心中的回归意识可能稍微淡薄一些。但是多年在外总是免不了偶尔迸发的乡愁。这种由年少时单纯的想家渐渐糅合乡里乡外诸多情绪演化的特殊情感，总是在心底休眠，待到列车开动的时刻，仿佛是添加了催化剂，热烈的燃
可能这就是人生吧宁轩
早就听过梁实秋这个名字，但好像一直没有读过他的作品，终于这次知道了他是一个幽默睿智、腹有诗书、热爱生活、善于观察与思考的北平可爱老头儿。本书是一个散文集，分了五个Part，分别讲述他的生活爱好、观察到的众生、观察到的社会现象、各种美食、故人老友。半文言半白话的行文风格，就像喝酒一样，一开始读来生涉，就越读越下饭～全书最佳实属《雅舍》。边读雅舍的样子边在我心中建立，即使破烂不堪也难掩作者对它的喜爱，
白云下的九维湾第八十九章 Thebookworm新西兰
“路蔓，这些天想我了吗？我已经与医院请好了一周的假，这个圣诞节想与你一起驱车南下，带你到新西兰南岛的但尼丁地区，我长大的地方去看看……”镜头上的万克强带着轻松的微笑望着路蔓。他已经在对路蔓的思念中煎熬得太久了，他想将她拥抱在怀里，感受她那柔弱的身体所传递给他的那一份炽热和温柔，嗅着她发丝中所散发出来的那一份幽香。路蔓低下了头，没有对万克强所提出的度假计划做出回答。“Jimmy的姐姐Jessica回
喜欢读书的人，即使独处也不会觉得孤独喜欢听音乐
在这个世上，除了寒冷与饥饿，世上最难熬的恐怕就是孤独了。怎么消除孤独？读书是免于焦虑和孤独最好的捷径。爱读书的人，与书相伴，即便独处，也不会孤独。把闲暇时间用来读书，在书中遇见广阔而瑰丽的世界，才不会感到匮乏和空虚。用读书填满独处的时间，即使一个人生活也不会感到孤独。读书是化解孤独最好的办法，因为读书可以让自己活在一个深情的精神世界。
培养孩子语言表达能力必须掌握的三个原则用力读书用心做人
每天进步一点点，坚持带来大改变[if!supportLists]一、[endif]简单。语言学习最讲究氛围和环境。跟孩子对话句子要简短，一个句子中不能超过两个要点。单一对应，关注当下。比如你教给孩子“红色”，出示的题板上应该只有红色，而不能底色是红色，上面还画有一只苹果。我要求孩子每天坚持写一句话。昨天孩子写的是“我和爸爸姥姨家玩”，我给他添了一个“去”字，并且用了一撇一捺的修改符号。结果孩子在抄
夜晚风影2003
很多时候夜幕降临、万家灯火是家人团聚的时候、在同一个空间里、不同的地方有着不同的人生轨迹、没个灯光背后都会有着怎样的故事呢？夜晚总是让人浮想联翩、离开自己熟悉的城市、暮然回首曾经沧海都已过往云烟、世间的年轮在慢慢的消失殆尽、我以回不去的生活方式、让我如同在一个大大的群体中慢慢的消减着自我的精神毅力。变成了一个充满惰性与圆滑世故的分子。岁月这把刀在每个人的身上留下的伤疤永远无法弥补愈合、伤口时时提醒
《文明、现代化、价值投资与中国》生芳在定投
今天定投课堂读书会开启了新一轮的共读活动，本轮共读的书籍是《文明、现代化、价值投资与中国》。今天带着此问题共读：资产管理是服务性行业，它和其他服务业相比不一样的地方在哪里？第一点：这个行业的用户在绝大多数时间里，不知道且无法判断产品的好坏。另外一点，这个行业总体来说薪酬高于其他任何行业。也就是脱离对客户财富增长的贡献。实际上真正为客户提供的服务有限。产品很多时候只是为从业人员自己提供了很高的回报。
日精进打卡第二十八天 7ce89867b4c2
陆晓磊～品质部日精进打卡第28天六项精进0遍大学0遍经典名句分享很多东西放到时间里去就能看清。要么越走越远，要么越走越近。行为实践一、修身：（对自己个人）锻炼半小时早睡早起二、齐家：（对家庭和家人）和爸爸妈妈聊天三、建工：（对工作）【省～觉悟】每天坚持做一件重复的小事看似很简单，其实很难，但是当自己由坚持变为习惯后，每天的坚持就如同吃饭睡觉一样简单。【感谢】感谢爸爸妈妈付出培养【志愿】发愿感召十万
前端Axios搭配Vue（认清Axios，Axios结合Vue发出Ajax请求，返回JSON数据案例！简洁易懂。）酸奶代码前端 vue.js javascript json ajax
一.什么是Axios1.axios是独立于vue的一个项目，不是Vue的一部分2.axios通常和Vue一起使用，实现Ajax操作3.Axios是一个基于promise的HTTP库axios官方文档二.引入Axios库文件1.可以直接引用2.可以下载Axios的js文件导入下载此js文件三.使用Axios配合Vue发出Ajax请求案例在Vue中使用Axios，向服务器发送Ajax请求，将获取的js
IP地址与子网划分 IP地址查询 tcp/ip 网络服务器 ip
子网的划分，实际上就是设计子网掩码的过程，它指的是指将一个给定的IP网络地址空间划分为更小的子网络。在子网掩码中用1和0来分别网络号和主机号，其中是1的表示是网络部分，0表示的是主机部分，所有主机号中的最后一个主机号为广播地址。例如，C类网络的默认子网掩码是255.255.255.0，用二进制表示为：11111111.11111111.11111111..00000000。IP地址范围与主机号范围
ZK springboot整合zookeeper 小P聊技术
1资源资源信息版本号备注zookeeper3.4.10IP:192.168.51.4springboot2.1.5.RELEASEprettyZoo2.0zookeeper可视化工具zookeeper可视化工具下载springboot-zookeeper-demo源码下载2zookeeper安装需要安装zookeeper，如果未安装，可参考博文：ZKzookeeper单机安装与配置3springb
穷算命，富烧香，穷人富人拜佛拜神拜天地，归根到底都是在拜自己的欲望。君安否
1、于努力变强的人而言，艰难困苦就像一层层阶梯，通往成功的高度；于懒惰的人而言，磨难挫折就如泥潭一般，使人越陷越深，最终淹没。2、自律赢来的，是你对现实的自主感，那才是真正的自由。3、苦与乐，是冤家，也是亲家，最大的欢乐，往往包含在巨大的艰辛之中，犹如明珠藏于大海，宝藏埋于深山。4、想换个城市，换个圈子，换一个不一样的活法，可是人一旦长大了，顾虑的东西实在太多了。5、人生就像蒲公英，看似自由，却往
生为何故 495ee20980ed
生为何故依稀记得，从高中起，脑子里常冒出些超乎我年龄与认知的疑问，我活着的意义？我的归宿在哪？我想这些问题应当是智者与哲学家的议题，与我这乳臭未除的小子何干，可它们早已幻化为幽灵，扎根于我脑海，尤其喜欢在夜深人静的时候拷问我，可似乎我没有答案来搪塞，久久折磨于我，某天转念一想，我渴望什么？好像能搪塞住它，就这样渴望伴我度过高中后半载和大学前半载，渴望终会泯灭，我才醒悟过来，渴望与归宿、意义不是一码
今日喜欢的文案 liaolicy
被疫情打扰下，才过不久的中秋少了些热闹，但祝福却一点也不少。来自某品牌的视频文案，《代表月亮祝福你》。亲爱的朋友们每个认真生活的你都值得被好好祝福所以这个中秋我想给你送上一个最大最圆最亮的祝你一切安好把平常的小日子过成幸福的好日子祝你永远做个孩子带着最纯粹的热爱去歌唱生命与爱祝你被生活亲吻虽然我们都知道它并非总是安稳祝你一路顺风希望有我陪伴前程不再孤单祝你每天快乐匆忙奔波也能分享快乐祝你继续可爱继
运维学习————Zookeeper(2) 乆乄学习
目录一、zk节点和节点类型1、节点类型2、常用命令1、客户端链接2、常用命令3、权限控制相关命令特性授权格式测试一、zk节点和节点类型1、节点类型1、PERSISTENT--持久化目录节点客户端与zookeeper断开连接后，该节点依旧存在2、PERSISTENT_SEQUENTIAL-目持久化顺序编号录节点客户端与zookeeper断开连接后，该节点依旧存在，只是Zookeeper给该节点名称进
活好：与105岁老人的对话木子读吧
一个百岁老人发自肺腑的每一句话，都是生命酿造出来的原浆。他就是日本皇室家庭医生的日野原重明先生。我也就是在今晚，在拜读了一个102岁老人写出这本《活好》后，感悟到了“人这一生一定会遇到很多很多的困难和痛苦，但是困难和痛苦越大，越会发现那个了不起的自己，与苦难相比，得到的幸福和喜悦终将会更多。那些痛苦和困难的到来，都是为了成就更好的自己。”生命是什么？生命是一种能量体，看不到，但确实存在。生命不在心
2019-07-10 刘会丽
刘会丽焦点解决网络初级14期，坚持分享第133天。读书打卡第20天，《尊重与希望》。我们要允许别人说痛苦，允许自己的孩子跌倒，允许自己家人的故事流淌，不管这个故事是欢喜的，愤怒的，或者是挫败的，独特性，帮原生态的故事，被接纳被包容，我们发现能从故事中发现宝，故事其实是中医里面的气，太久的故事不说，会堵住人，会难受，好好的说故事，气就通了，不要带着故事去睡觉，要让故事流动起来，如果现在的问题你会很无
抖音返利机器人抖音返利用什么软件氧惠购物达人
抖音返利软件哪个实用，佣金又高！抖音购物有办法省钱吗?在抖音买东西怎么走返利?抖音返利用什么软件?抖音返利平台有哪些?抖音返利是真的吗？抖音产品有返利软件吗？抖音怎么下单返利？购物、看电影、点外卖、用氧惠APP！更优惠！氧惠（全网优惠上氧惠）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面，送1:1超级补贴(邀请好友自购多少，你就推广得多少，非常厉害)，欢迎各位团队
怎样领唯品会隐藏优惠券？唯品会隐藏优惠券怎么获得氧惠评测
下面小编就带大家一起来看看，唯品会隐藏优惠券怎么获得购物、看电影、点外卖、用氧惠APP！更优惠！氧惠（全网优惠上氧惠）——是与以往完全不同的抖客+淘客app！2022全新模式，我的直推也会放到你下面，送1:1超级补贴(邀请好友自购多少，你就推广得多少，非常厉害)，欢迎各位团队长体验！也期待你的加入。氧惠邀请码888999，注册就帮你推广，一起做到百万团队！氧惠邀请码888999工具/原料荣耀20p
日更｜微故事：《梁山伯与祝英台》小思设计
梁山伯和祝英台是中国古代著名的爱情故事中的主角。梁山伯出生在一个富裕的家庭，祝英台则是一个出身卑微的女子。两人在儿时相遇，相互喜欢，但由于社会阶级和家庭背景的差异，他们的爱情一直没有得到承认和认可。后来，梁山伯成年后被父亲安排到外地读书，离开了祝英台。在他离开的时候，祝英台送给他一只手绣的蝴蝶。梁山伯在外读书期间一直思念祝英台，但他不知道祝英台的下落，只能把思念写成诗歌表达出来。在此期间，祝英台被
Puppeteer-Sharp：无头浏览器.NET API探索井唯喜
Puppeteer-Sharp：无头浏览器.NETAPI探索puppeteer-sharp项目地址:https://gitcode.com/gh_mirrors/pup/puppeteer-sharp项目介绍Puppeteer-Sharp是一个.NET版本的官方Node.jsPuppeteer库的移植。它允许开发者在.NET环境下远程控制Chromium或Chrome浏览器，进行网页操作、截图、生
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