Le pointeur intelligent RefPtr
Glib::RefPtr is a smartpointer. Specifically, it is a reference-counting smartpointer. You might be familiar with std::auto_ptr<>, std::unique_ptr<> and std::shared_ptr<>, which are also smartpointers. Glib::RefPtr<> is similar to std::shared_ptr<>, which is also reference-counting. Glib::RefPtr<> was introduced long before there was a reference-counting smartpointer in the C++ Standard Library.
Reference
Un pointeur intelligent se comporte plus ou moins comme un pointeur normal. Voici quelques exemples.

Copie
Vous pouvez copier les RefPtr, tout comme des pointeurs normaux. Mais contrairement aux pointeurs normaux, vous n'avez pas à vous soucier de la destruction de l'instance sous-jacente.

Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
Glib::RefPtr<Gdk::Pixbuf> refPixbuf2 = refPixbuf;

Of course this means that you can store RefPtrs in standard containers, such as std::vector or std::list.

std::list< Glib::RefPtr<Gdk::Pixbuf> > listPixbufs;
Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
listPixbufs.push_back(refPixbuf);

Déréférencement
Vous pouvez déréférencer un pointeur intelligent avec l'opérateur -> pour appeler des fonctions membres de l'instance subjacente, comme pour un pointeur normal.

Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
int width = refPixbuf->get_width();

Mais contrairement à la plupart des pointeurs, vous ne pouvez pas utiliser l'opérateur * pour avoir accès à l'instance sous-jacente.

Glib::RefPtr<Gdk::Pixbuf> refPixbuf = Gdk::Pixbuf::create_from_file(filename);
Gdk::Pixbuf& underlying = *refPixbuf; //Syntax error - will not compile.

Forçage de type
You can cast RefPtrs to base types, just like normal pointers.

Glib::RefPtr<Gtk::TreeStore> refStore = Gtk::TreeStore::create(columns);
Glib::RefPtr<Gtk::TreeModel> refModel = refStore;

Cela signifie que toute fonction membre prenant en paramètre un const Glib::RefPtr<BaseType> peut également prendre un const Glib::RefPtr<DerivedType>. Le forçage est implicite, tout comme pour un pointeur normal.
Vous pouvez aussi faire un forçage sur un type dérivé, mais la syntaxe est alors différente de celle pour un pointeur normal.

Glib::RefPtr<Gtk::TreeStore> refStore =
Glib::RefPtr<Gtk::TreeStore>::cast_dynamic(refModel);
Glib::RefPtr<Gtk::TreeStore> refStore2 =
Glib::RefPtr<Gtk::TreeStore>::cast_static(refModel);

Vérification du pointeur NULL
Comme pour les pointeurs normaux, vous pouvez vérifier si un pointeur RefPtr ne pointe sur rien.

Glib::RefPtr<Gtk::TreeModel> refModel = m_TreeView.get_model();
if(refModel)
{
  int cols_count = refModel->get_n_columns();
  ...
}

Mais contrairement aux pointeurs normaux, les RefPtr sont automatiquement initialisés à NULL ; vous n'avez pas à faire cela vous-même.

Constance
The use of the const keyword in C++ is not always clear. You might not realise that const Something* declares a pointer to a const Something. The pointer can be changed, but not the Something that it points to.
Ainsi, l'équivalent RefPtr de Quelquechose* pour un paramètre de fonction membre est const Glib::RefPtr<Quelquechose>& et l'équivalent de const Quelquechose* est const Glib::RefPtr<const Quelquechose>&.
Le const ... & qui entoure les deux expressions est juste une question d'efficacité, c'est comme utiliser const std::string& à la place de std::string pour un paramètre de fonction pour éviter une recopie non nécessaire.