gtk_entry_set_text fuite mémoire

Bonjour à tous,
J'utilise GTK+ (version 2.10) depuis quelques mois et j'ai un soucis avec avec la fonction gtk_entry_set_text qui me crée des fuites de mémoire

En effet, je fais une mise à jour en continue (dans une boucle while)de mon entrée afin d'avoir un résultat visible en temps réel:

voici la partie du code concernée:

gchar *freq_to_display;
while (!gtk_main_iteration_do(0))
{
freq_to_display = g_strdup_printf ("%0.4f", average);
gtk_entry_set_text(GTK_ENTRY (My_entry), freq_to_display);
g_free(freq_to_display);
}

où "average" est une constante de type float et qui est continuellement modifiée autre part dans mon programme.
Je précise également que lorsque je remplace "average" par une valeur constante (voir ci dessous) dans cette boucle, je n'ai plus ce problème de fuite de mémoire:

average = 0;
freq_to_display = g_strdup_printf ("%0.4f", average);

OU

freq_to_display = g_strdup_printf ("%0.4f", 0);


Ceci dit, le problème pourrai être lié au fait que l'on change la valeur du gtk_entry_set_text à chaque fois et donc cette fonction allouerai un espace mémoire pour chaque valeur et sans toute fois la désallouée lorsqu'une nouvelle valeur est mise à jour.

J'espère que quelqu'un pourra m'apporter d'amples informations concernant ce problème et si possible une solution.
Merci d'avance

Bonjour,

GTK 2.10, c'est déjà très ancien... Peux tu au moins nous donner un exemple minimal de code qui compile et montre le problème ?

Salut, désolé pour le réponse tardive
voici un bout de code qui compile:


GtkWidget *window;
GtkWidget *fixed, *bouton, Value_Entry;
int compt = 0;

int main (int argc, char **argv)
{
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);

button = gtk_button_new_with_label("Browse ");
gtk_fixed_put(GTK_FIXED(fixed), button, 50, 50);
gtk_widget_set_size_request(button, 60, 25);

Value_Entry = gtk_entry_new_with_max_length(10);
gtk_entry_set_text(GTK_ENTRY (Value_Entry), "0");

g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK (display), NULL);
g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);

gtk_widget_show_all (window);
gtk_main();

}

/* fonction display */
void open_image(void)
{
char value_in_char[10];
compt ++;

g_ascii_dtostr (value_in_char, sizeof(value_in_char), compt );
gtk_entry_set_text(GTK_ENTRY (Value_Entry), (const gchar*)value_in_char);
g_free(value_in_char);

}


En effet, chaque fois que j'appuie sur le bouton "bouton", la valeur de "compt" s'incrémente se s'affiche dans la zone correspondante. Mais cependant, je constate également que j'ai, à chaque fois, une fuite de mémoire d'environ 4Ko.
Merci d'avance pour le retour

Manifestement, le code proposé ne compile pas chez moi.

Quelques erreurs données par le compilateur:
* le widget déclaré bouton devient button dans le programme,
* la chaîne de caractères value_in_char est un tableau qui va disparaître quand on sort de la fonction open_image(), il ne faut pas lui appliquer g_free() et ce n'est pas un casting qui va changer ceci,
* le callback display n'existe pas et la fonction open_image() qui semble vouloir en faire office n'a pas les arguments requis pour la fonction appelée par le signal "clicked"
Bref, je me demande comment on peut arriver à compiler ce programme (avec gcc, l'option -Wall est recommandée)

Ensuite, comme le dit liberforce, Gtk-2.10, c'est terriblement vieux (la version actuelle est 2.24, pour ne pas parler de GTK3).

Boonjour,
*Désolé mais j'avais fais omis quelques éléments en faisant le copié-collé. voici donc le code complet qui compile bien sous GTK 2.10.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>




void display(void);
GtkWidget *window;
GtkWidget *fixed, *bouton_test, *Value_Entry;
int compt = 0;

int main (int argc, char **argv)
{
gtk_init(&argc, &argv);

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);

bouton_test = gtk_button_new_with_label("Press Here");
gtk_fixed_put(GTK_FIXED(fixed), bouton_test, 50, 50);
gtk_widget_set_size_request(bouton_test, 100, 25);

Value_Entry = gtk_entry_new_with_max_length(10);
gtk_fixed_put(GTK_FIXED(fixed), Value_Entry, 50, 120);
gtk_widget_set_size_request(Value_Entry, 100, 25);
gtk_entry_set_text(GTK_ENTRY (Value_Entry), "0");

g_signal_connect (G_OBJECT(bouton_test), "clicked", G_CALLBACK (display), NULL);
g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);

gtk_widget_show_all (window);

gtk_main();

return 0;
}



/* fonction display */
void display(void)
{
char value_in_char[10];
compt ++;

g_ascii_dtostr (value_in_char, sizeof(value_in_char), compt );
gtk_entry_set_text(GTK_ENTRY (Value_Entry), (const gchar*)value_in_char);
g_free(value_in_char);

}


le problème reste donc le même (fuite de mémoire avec gtk_entry_set_text).
en attendant, je vais voir dans quelle mesure mettre à niveau ma version de GTK.
Merci pour vos retours

S'il te plait, teste ton code avant de le poster. Là tu fais un g_free sur un tableau que tu n'as pas alloué dynamiquement, ça crashe dès le premier clic sur le bouton. J'aimerais aussi savoir comment tu mesures la mémoire pour dire qu'il y a une fuite mémoire.

J'ai testé avec GTK 2.24.17 et GTK 3.6.4 sous Mageia 2, et effectivement, j'ai l'impression dans les 2 cas que la consommation mémoire augmente.

Effectivement il n'y a pas de g_free.
Je teste la mémoire avec le moniteur de ressources sous Windows; en cliquant sur le nom de mon programme dans la liste des processus, je peux suivre l'évolution de la mémoire de mon application.

En outre, j'ai également installé GTK3 et j'ai testé mon application mais j'ai toujours le même problème.

Merci pour vos retours.