GTK内存泄漏hello_world程序

Question

所以...我试图从我的GTK + 3程序中消除一些内存泄漏。我认为回顾一下一些简单的例子来看看是否有一些我忘记的清理工具是个好主意，但是文档中提供的hello_world程序也有泄漏。 （下面的Valgrind输出）。

这些泄漏是否可接受？如果是这样，是否还有其他一些应用程序用于调试GTK程序？

==13717== Memcheck, a memory error detector 
==13717== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al. 
==13717== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info 
==13717== Command: ./a 
==13717== 
Hello World 
==13717== 
==13717== HEAP SUMMARY: 
==13717==  in use at exit: 1,578,162 bytes in 11,614 blocks 
==13717== total heap usage: 45,699 allocs, 34,085 frees, 6,461,970 bytes allocated 
==13717== 
==13717== LEAK SUMMARY: 
==13717== definitely lost: 2,560 bytes in 5 blocks 
==13717== indirectly lost: 6,656 bytes in 207 blocks 
==13717==  possibly lost: 363,228 bytes in 1,937 blocks 
==13717== still reachable: 1,205,718 bytes in 9,465 blocks 
==13717==   suppressed: 0 bytes in 0 blocks 
==13717== Rerun with --leak-check=full to see details of leaked memory 
==13717== 
==13717== For counts of detected and suppressed errors, rerun with: -v 
==13717== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2) 

代码：

#include <gtk/gtk.h> 

/* This is a callback function. The data arguments are ignored 
* in this example. More on callbacks below. 
*/ 
static void 
print_hello (GtkWidget *widget, 
      gpointer data) 
{ 
    g_print ("Hello World\n"); 
} 

static gboolean 
on_delete_event (GtkWidget *widget, 
       GdkEvent *event, 
       gpointer data) 
{ 
    /* If you return FALSE in the "delete_event" signal handler, 
    * GTK will emit the "destroy" signal. Returning TRUE means 
    * you don't want the window to be destroyed. 
    * 
    * This is useful for popping up 'are you sure you want to quit?' 
    * type dialogs. 
    */ 

    g_print ("delete event occurred\n"); 

    return TRUE; 
} 

int 
main (int argc, 
     char *argv[]) 
{ 
    /* GtkWidget is the storage type for widgets */ 
    GtkWidget *window; 
    GtkWidget *button; 

    /* This is called in all GTK applications. Arguments are parsed 
    * from the command line and are returned to the application. 
    */ 
    gtk_init (&argc, &argv); 

    /* create a new window, and set its title */ 
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL); 
    gtk_window_set_title (GTK_WINDOW (window), "Hello"); 

    /* When the window emits the "delete-event" signal (which is emitted 
    * by GTK+ in response to an event coming from the window manager, 
    * usually as a result of clicking the "close" window control), we 
    * ask it to call the on_delete_event() function as defined above. 
    * 
    * The data passed to the callback function is NULL and is ignored 
    * in the callback function. 
    */ 
    g_signal_connect (window, "delete-event", G_CALLBACK (on_delete_event), NULL); 

    /* Here we connect the "destroy" event to the gtk_main_quit() function. 
    * 
    * This signal is emitted when we call gtk_widget_destroy() on the window, 
    * or if we return FALSE in the "delete_event" callback. 
    */ 
    g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); 

    /* Sets the border width of the window. */ 
    gtk_container_set_border_width (GTK_CONTAINER (window), 10); 

    /* Creates a new button with the label "Hello World". */ 
    button = gtk_button_new_with_label ("Hello World"); 

    /* When the button receives the "clicked" signal, it will call the 
    * function print_hello() passing it NULL as its argument. 
    * 
    * The print_hello() function is defined above. 
    */ 
    g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL); 

    /* The g_signal_connect_swapped() function will connect the "clicked" signal 
    * of the button to the gtk_widget_destroy() function; instead of calling it 
    * using the button as its argument, it will swap it with the user data 
    * argument. This will cause the window to be destroyed by calling 
    * gtk_widget_destroy() on the window. 
    */ 
    g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window); 

    /* This packs the button into the window. A GtkWindow inherits from GtkBin, 
    * which is a special container that can only have one child 
    */ 
    gtk_container_add (GTK_CONTAINER (window), button); 

    /* The final step is to display this newly created widget... */ 
    gtk_widget_show (button); 

    /* ... and the window */ 
    gtk_widget_show (window); 

    /* All GTK applications must have a gtk_main(). Control ends here 
    * and waits for an event to occur (like a key press or a mouse event), 
    * until gtk_main_quit() is called. 
    */ 
    gtk_main(); 

    return 0; 
} 

Answer 1

这个答案是从回答同样的问题汇编（上现已解散www.gtkforums.com）。

当谈到分配和释放应用程序生命周期所需的内部缓冲区时，GTK +非常懒惰。例如，它可以在初始化期间为应用程序的生命周期所需的一个查找表分配一个内存区域。 GTK +将永远不会释放这个。对Valgrind来说，这看起来像是一个内存泄漏（从技术上讲它是这样），但是作为一个优化，GTK +不会释放它，因为它在应用程序退出时会被释放，所以不会出错。这就是为什么你需要压缩文件，以便Valgrind可以忽略这些文件。问题是你需要用大多数GTK +版本改变来改变它们。

的抑制文件库： https://github.com/dtrebbien/GNOME.supp

克隆库后，就可以产生抑制的文件（还附带了巧舌如簧，GDK，和其他人）与“让”，然后的valgrind是指他们像所以：

valgrind ./a --suppression=/path/to/gtk3.supp 

Answer 2

为了调试油嘴/ GTK程序我会用这个命令：

G_SLICE=debug-blocks valgrind --tool=memcheck --leak-check=full <gtk program> 

G_SLICE =调试模块将关闭GTK先进的内存管理允许的valgrind以显示正确的结果。

--leak-check = full将显示泄漏内存块的堆栈跟踪。

您还可以使用--show-reachable = yes查看程序退出时尚未释放的所有内存块的堆栈跟踪。

还有一个massif valgrind工具，用于跟踪内存使用情况，以显示程序的哪些部分使用最多的内存。

下地块运行程序：

G_SLICE=always-malloc valgrind --tool=massif --detailed-freq=2 --max-snapshots=400 --num-callers=20 <gtk program> 

显示结果：

ms_print massif.out.<pid>