#### Automatic Cleanup

GLib provides a set of macros that wrap the GCC extension for automatic cleanup of variables when they go out of scope.

These macros can only be used with GCC and GCC-compatible C compilers.

## Variable declaration

`g_auto(TypeName)`

  Helper to declare a variable with automatic cleanup.

  The variable is cleaned up in a way appropriate to its type when the variable goes out of scope. The `TypeName` of the variable must support this.

  The way to clean up the type must have been defined using one of the macros `G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC()` or `G_DEFINE_AUTO_CLEANUP_FREE_FUNC()`.

  This feature is only supported on GCC and clang. This macro is not defined on other compilers and should not be used in programs that are intended to be portable to those compilers.

  This macro meant to be used with stack-allocated structures and non-pointer types. For the (more commonly used) pointer version, see `g_autoptr()`.

  This macro can be used to avoid having to do explicit cleanups of local variables when exiting functions. It often vastly simplifies handling of error conditions, removing the need for various tricks such as `goto out` or repeating of cleanup code. It is also helpful for non-error cases.

  Consider the following example:

      GVariant *
      my_func(void)
      {
        g_auto(GQueue) queue = G_QUEUE_INIT;
        g_auto(GVariantBuilder) builder;
        g_auto(GStrv) strv;

        g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
        strv = g_strsplit("a:b:c", ":", -1);

        // ...

        if (error_condition)
          return NULL;

        // ...

        return g_variant_builder_end (&builder);
      }

  You must initialize the variable in some way — either by use of an initialiser or by ensuring that an `_init` function will be called on it unconditionally before it goes out of scope.

  Since: 2.44

`g_autoptr(TypeName)`

  Helper to declare a pointer variable with automatic cleanup.

  The variable is cleaned up in a way appropriate to its type when the variable goes out of scope. The `TypeName` of the variable must support this. The way to clean up the type must have been defined using the macro `G_DEFINE_AUTOPTR_CLEANUP_FUNC()`.

  This feature is only supported on GCC and clang. This macro is not defined on other compilers and should not be used in programs that are intended to be portable to those compilers.

  This is meant to be used to declare pointers to types with cleanup functions. The type of the variable is a pointer to `TypeName`. You must not add your own `*`.

  This macro can be used to avoid having to do explicit cleanups of local variables when exiting functions. It often vastly simplifies handling of error conditions, removing the need for various tricks such as `goto out` or repeating of cleanup code. It is also helpful for non-error cases.

  Consider the following example:

      gboolean
      check_exists(GVariant *dict)
      {
        g_autoptr(GVariant) dirname, basename = NULL;
        g_autofree gchar *path = NULL;

        dirname = g_variant_lookup_value (dict, "dirname", G_VARIANT_TYPE_STRING);
        if (dirname == NULL)
          return FALSE;

        basename = g_variant_lookup_value (dict, "basename", G_VARIANT_TYPE_STRING);
        if (basename == NULL)
          return FALSE;

        path = g_build_filename (g_variant_get_string (dirname, NULL),
                                 g_variant_get_string (basename, NULL),
                                 NULL);

        return g_access (path, R_OK) == 0;
      }

  You must initialise the variable in some way — either by use of an initialiser or by ensuring that it is assigned to unconditionally before it goes out of scope.

  See also: `g_auto()`, `g_autofree()` and `g_steal_pointer()`.

  Since: 2.44

`g_autofree`

  Macro to add an attribute to pointer variable to ensure automatic cleanup using `g_free()`.

  This macro differs from `g_autoptr()` in that it is an attribute supplied before the type name, rather than wrapping the type definition. Instead of using a type-specific lookup, this macro always calls `g_free()` directly.

  This means it’s useful for any type that is returned from `g_malloc()`.

  Otherwise, this macro has similar constraints as `g_autoptr()`: only supported on GCC and clang, the variable must be initialized, etc.

      gboolean
      operate_on_malloc_buf (void)
      {
        g_autofree guint8* membuf = NULL;

        membuf = g_malloc (8192);

        // Some computation on membuf

        // membuf will be automatically freed here
        return TRUE;
      }

  Since: 2.44

`g_autolist(TypeName)`

  Helper to declare a list variable with automatic deep cleanup.

  The list is deeply freed, in a way appropriate to the specified type, when the variable goes out of scope. The type must support this.

  This feature is only supported on GCC and clang. This macro is not defined on other compilers and should not be used in programs that are intended to be portable to those compilers.

  This is meant to be used to declare lists of a type with a cleanup function. The type of the variable is a `GList *`. You must not add your own `*`.

  This macro can be used to avoid having to do explicit cleanups of local variables when exiting functions. It often vastly simplifies handling of error conditions, removing the need for various tricks such as `goto out` or repeating of cleanup code. It is also helpful for non-error cases.

  See also: `g_autoslist()`, `g_autoptr()` and `g_steal_pointer()`.

  Since: 2.56

`g_autoslist(TypeName)`

  Helper to declare a singly linked list variable with automatic deep cleanup.

  The list is deeply freed, in a way appropriate to the specified type, when the variable goes out of scope. The type must support this.

  This feature is only supported on GCC and clang. This macro is not defined on other compilers and should not be used in programs that are intended to be portable to those compilers.

  This is meant to be used to declare lists of a type with a cleanup function. The type of the variable is a `GSList *`. You must not add your own `*`.

  This macro can be used to avoid having to do explicit cleanups of local variables when exiting functions. It often vastly simplifies handling of error conditions, removing the need for various tricks such as `goto out` or repeating of cleanup code. It is also helpful for non-error cases.

  See also: `g_autolist()`, `g_autoptr()` and `g_steal_pointer()`.

  Since: 2.56

`g_autoqueue(TypeName)`

  Helper to declare a double-ended queue variable with automatic deep cleanup.

  The queue is deeply freed, in a way appropriate to the specified type, when the variable goes out of scope. The type must support this.

  This feature is only supported on GCC and clang. This macro is not defined on other compilers and should not be used in programs that are intended to be portable to those compilers.

  This is meant to be used to declare queues of a type with a cleanup function. The type of the variable is a `GQueue *`. You must not add your own `*`.

  This macro can be used to avoid having to do explicit cleanups of local variables when exiting functions. It often vastly simplifies handling of error conditions, removing the need for various tricks such as `goto out` or repeating of cleanup code. It is also helpful for non-error cases.

  See also: `g_autolist()`, `g_autoptr()` and `g_steal_pointer()`.

  Since: 2.62

## Type definition

`G_DEFINE_AUTOPTR_CLEANUP_FUNC(TypeName, func)`

  Defines the appropriate cleanup function for a pointer type.

  The function will not be called if the variable to be cleaned up contains `NULL`.

  This will typically be the `_free()` or `_unref()` function for the given type.

  With this definition, it will be possible to use `g_autoptr()` with the given `TypeName`.

      G_DEFINE_AUTOPTR_CLEANUP_FUNC(GObject, g_object_unref)

  This macro should be used unconditionally; it is a no-op on compilers where cleanup is not supported.

  Since: 2.44

`G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(TypeName, func)`

  Defines the appropriate cleanup function for a type.

  This will typically be the `_clear()` function for the given type.

  With this definition, it will be possible to use `g_auto()` with the given `TypeName`.

      G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(GQueue, g_queue_clear)

  This macro should be used unconditionally; it is a no-op on compilers where cleanup is not supported.

  Since: 2.44

`G_DEFINE_AUTO_CLEANUP_FREE_FUNC(TypeName, func, none_value)`

  Defines the appropriate cleanup function for a type.

  With this definition, it will be possible to use `g_auto()` with the given `TypeName`.

  This function will be rarely used. It is used with pointer-based typedefs and non-pointer types where the value of the variable represents a resource that must be freed. Two examples are `GStrv` and file descriptors.

  `none_value` specifies the “none” value for the type in question. It is probably something like `NULL` or `-1`.If the variable is found to contain this value then the free function will not be called.

      G_DEFINE_AUTO_CLEANUP_FREE_FUNC(GStrv, g_strfreev, NULL)

  This macro should be used unconditionally; it is a no-op on compilers where cleanup is not supported.

  Since: 2.44