GObject – 2.0: Floating References
Description: Reference for GObject-2.0: Floating References

#### Floating References

Note: Floating references are a C convenience API and should not be used in modern GObject code. Language bindings in particular find the concept highly problematic, as floating references are not identifiable through annotations, and neither are deviations from the floating reference behavior, like types that inherit from `GInitiallyUnowned` and still return a full reference from `g_object_new()`.

`GInitiallyUnowned` is derived from `GObject`. The only difference between the two is that the initial reference of a `GInitiallyUnowned` is flagged as a “floating” reference. This means that it is not specifically claimed to be “owned” by any code portion. The main motivation for providing floating references is C convenience. In particular, it allows code to be written as:

    container = create_container ();
    container_add_child (container, create_child());

If `container_add_child()` calls `g_object_ref_sink()` on the passed-in child, no reference of the newly created child is leaked. Without floating references, `container_add_child()` can only acquire a reference the new child, so to implement this code without reference leaks, it would have to be written as:

    Child *child;
    container = create_container ();
    child = create_child ();
    container_add_child (container, child);
    g_object_unref (child);

The floating reference can be converted into an ordinary reference by calling `g_object_ref_sink()`. For already sunken objects (objects that don’t have a floating reference anymore), `g_object_ref_sink()` is equivalent to `g_object_ref()` and returns a new reference.

Since floating references are useful almost exclusively for C convenience, language bindings that provide automated reference and memory ownership maintenance (such as smart pointers or garbage collection) should not expose floating references in their API. The best practice for handling types that have initially floating references is to immediately sink those references after `g_object_new()` returns, by checking if the `GType` inherits from `GInitiallyUnowned`. For instance:

    GObject *res = g_object_new_with_properties (gtype,
                                                 n_props,
                                                 prop_names,
                                                 prop_values);

    // or: if (g_type_is_a (gtype, G_TYPE_INITIALLY_UNOWNED))
    if (G_IS_INITIALLY_UNOWNED (res))
      g_object_ref_sink (res);

    return res;

Some object implementations may need to save an object’s floating state across certain code portions (an example is `GtkMenu` in GTK3), to achieve this, the following sequence can be used:

    // save floating state
    gboolean was_floating = g_object_is_floating (object);
    g_object_ref_sink (object);
    // protected code portion

    ...

    // restore floating state
    if (was_floating)
      g_object_force_floating (object);
    else
      g_object_unref (object); // release previously acquired reference

## Replacing floating references with annotations

You should avoid basing your object hierarchy on floating references, as they are hard to understand even in C, and introduce additional limitations when consuming a GObject-based API in other languages.

One way to express the ownership transfer between ‘container’ and ‘child’ instances is to use ownership transfer annotations in your documentation and introspection data. For instance, you can implement this pattern:

    container_add_child (container, create_child ());

without leaking by having `container_add_child()` defined as:

    /**
     * container_add_child:
     * @self: a container
     * @child: (transfer full): the child to add to the container
     *
     * ...
     */
    void
    container_add_child (Container *container,
                         Child *child)
    {
      container->children = g_list_append (container->children, child);
    }

The container does not explicitly acquire a reference on the child; instead, the ownership of the child is transferred to the container. The transfer annotation will be used by language bindings to ensure that there are no leaks; and documentation tools will explicitly note that the callee now owns the value passed by the caller.

## Replacing floating references with weak references

Another option for replacing floating references is to use weak references in place of strong ones. A ‘container’ can acquire a weak reference on the ‘child’ instance by using `g_object_weak_ref()`. Once the child instance loses its last strong reference, the container holding a weak reference is notified, and it can either remove the child from its internal list, or turn a weak reference into a strong one.