Gestión de memoria de objetos GTK+ usando Glade y gtkmm

I am using C++ to create a program using GTK+ and glade. I am concerned about the memory management of the objects that the glade creates. For example, I create a glade file consisting of a window, a button and two entry fields. Then in my C++ code I create an object from that file and get a pointer to that window. My question is, do I have to safely deallocate the window object when I am done? If not, why do I not have to? Below is a sample of my code...

#include <gtkmm.h>
#include "MattWindow.h"

#include <iostream>

using namespace std;

void buttonpush();

int main(int argc, char* argv[])
{
    //This line initializes the GTK+ system
    Gtk::Main kit(argc,argv);

    //Declare a pointer to a window
    Gtk::Window* window = 0;

    try
    {
        //Load the glade file
        Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_file("layout.glade");

        Assign window to point to the window object
        builder->get_widget("window1",window);
        window->show();
    }
    catch(Gtk::BuilderError& e)
    {
        cout<<e.what();
    }

    //Start everything up
    Gtk::Main::run();



    //Who destroys the object that window is currently pointing to?

    return 0;
}

void buttonpush()
{

}

preguntado el 06 de septiembre de 12 a las 17:09

2 Respuestas

Desde el Manual de referencia GTK +:

A GtkBuilder holds a reference to all objects that it has constructed and drops these references when it is finalized. This finalization can cause the destruction of non-widget objects or widgets which are not contained in a toplevel window. For toplevel windows constructed by a builder, it is the responsibility of the user to call gtk_widget_destroy() to get rid of them and all the widgets they contain.

The functions gtk_builder_get_object() and gtk_builder_get_objects() can be used to access the widgets in the interface by the names assigned to them inside the UI description. Toplevel windows returned by these functions will stay around until the user explicitly destroys them with gtk_widget_destroy(). Other widgets will either be part of a larger hierarchy constructed by the builder (in which case you should not have to worry about their lifecycle), or without a parent, in which case they have to be added to some container to make use of them. Non-widget objects need to be reffed with g_object_ref() to keep them beyond the lifespan of the builder.

To answer your question: yes, you should manually destroy the window when you're done with it.

Respondido el 06 de Septiembre de 12 a las 21:09

GTK widgets are reference counted. When you close or destroy your window, it will release its last reference and be deallocated. (Although I believe the builder also holds a reference - but that should be released when the builder is destroyed.)

Respondido el 06 de Septiembre de 12 a las 21:09

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.