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>