Glade and Gtk::Builder
Although you can use C++ code to instantiate and arrange widgets, this can soon become tedious and repetitive. And it requires a recompilation to show changes. The Glade application allows you to layout widgets on screen and then save an XML description of the arrangement. Your application can then use the Gtk::Builder API to load that XML file at runtime and obtain a pointer to specifically named widget instances.
This has the following advantages:
Less C++ code is required.
UI changes can be seen more quickly, so UIs are able to improve.
Designers without programming skills can create and edit UIs.
You still need C++ code to deal with User Interface changes triggered by user actions, but using Gtk::Builder for the widget layout allows you to focus on implementing that functionality.

Loading the .glade file
Gtk::Builder must be used via a Glib::RefPtr. Like all such classes, you need to use a create() method to instantiate it. For instance,

Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_file("basic.glade");

This will instantiate the windows defined in the .glade file, though they will not be shown immediately unless you have specified that via the Properties window in Glade.
To instantiate just one window, or just one of the child widgets, you can specify the name of a widget as the second parameter. For instance,

Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create_from_file("basic.glade", "treeview_products");

Accessing widgets
To access a widget, for instance to show() a dialog, use the get_widget() method, providing the widget's name. This name should be specified in the Glade Properties window. If the widget could not be found, or is of the wrong type, then the pointer will be set to 0.

Gtk::Dialog* pDialog = 0;
builder->get_widget("DialogBasic", pDialog);

Gtk::Builder checks for a null pointer, and checks that the widget is of the expected type, and will show warnings on the command line about these.
Remember that you are not instantiating a widget with get_widget(), you are just obtaining a pointer to one that already exists. You will always receive a pointer to the same instance when you call get_widget() on the same Gtk::Builder, with the same widget name. The widgets are instantiated during Gtk::Builder::create_from_file().
get_widget() returns child widgets that are manage()ed (see the Memory Management chapter), so they will be deleted when their parent container is deleted. So, if you get only a child widget from Gtk::Builder, instead of a whole window, then you must either put it in a Container or delete it. Windows (such as Dialogs) cannot be managed because they have no parent container, so you must delete them at some point.

Example
This simple example shows how to load a Glade file at runtime and access the widgets with Gtk::Builder.
Source Code

Using derived widgets
You can use Glade to layout your own custom widgets derived from gtkmm widget classes. This keeps your code organized and encapsulated. Of course you won't see the exact appearance and properties of your derived widget in Glade, but you can specify its location and child widgets and the properties of its gtkmm base class.
Use Gtk::Builder::get_widget_derived() like so:

DerivedDialog* pDialog = 0;
builder->get_widget_derived("DialogBasic", pDialog);

Your derived class must have a constructor that takes a pointer to the underlying C type, and the Gtk::Builder instance. All relevant classes of gtkmm typedef their underlying C type as BaseObjectType (Gtk::Dialog typedefs BaseObjectType as GtkDialog, for instance).
You must call the base class's constructor in the initialization list, providing the C pointer. For instance,

DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder)
: Gtk::Dialog(cobject)
{
}

You could then encapsulate the manipulation of the child widgets in the constructor of the derived class, maybe using get_widget() or get_widget_derived() again. For instance,

DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder)
: Gtk::Dialog(cobject),
  m_builder(builder),
  m_pButton(0)
{
  //Get the Glade-instantiated Button, and connect a signal handler:
  m_builder->get_widget("quit_button", m_pButton);
  if(m_pButton)
  {
    m_pButton->signal_clicked().connect( sigc::mem_fun(*this, &DerivedDialog::on_button_quit) );
  }
}

Example
This example shows how to load a Glade file at runtime and access the widgets via a derived class.
Source Code