主页 / coding / 问题 / 79198411
Accepted
9-Pin
Asked: 2024-11-18 08:17:42 +0800 CST

关于已移除小部件的 GTK 内存管理的说明

  • 772

当我从容器中移除小部件时，我需要澄清 GTK 的内存管理。

/* Create a label widget with a floating reference. */
GtkWidget *lbl_text = gtk_label_new ("Text");

/* Create a grid container widget. */
GtkWidget *grid_text = gtk_grid_new ();

/* Add the label to the grid, which replaces the floating reference with a standard reference. */
gtk_grid_attach ( GTK_GRID(grid_text), lbl_text, 0, 0, 3, 1);

当我销毁网格时grid_text，GTK 将标签上的引用计数减为零，并释放标签的内存。一切顺利。

如果我从网格中删除标签，标签的引用计数会发生什么变化？

gtk_grid_remove (GTK_GRID(grid_text), lbl_text);

现在它lbl_text的引用计数是否为零并且被销毁了，或者它是否有一个浮动引用，我需要使用 手动销毁它g_object_unref()？

c

1 个回答

  1. Best Answer

    我们可以看一下源代码：

    gtk_grid_remove--> gtk_widget_unparent-->g_object_unref

    因此，快速的答案是清理已完成。但是，有些代码有点复杂...

    以下是gtk_grid_remove代码：

    static void
gtk_grid_remove (GtkContainer *container,
                 GtkWidget    *child)
{
  GtkGrid *grid = GTK_GRID (container);
  GtkGridPrivate *priv = grid->priv;
  GtkGridChild *grid_child;
  GList *list;

  for (list = priv->children; list; list = list->next)
    {
      grid_child = list->data;

      if (grid_child->widget == child)
        {
          gboolean was_visible = _gtk_widget_get_visible (child);

          gtk_widget_unparent (child);

          priv->children = g_list_remove (priv->children, grid_child);

          g_slice_free (GtkGridChild, grid_child);

          if (was_visible && _gtk_widget_get_visible (GTK_WIDGET (grid)))
            gtk_widget_queue_resize (GTK_WIDGET (grid));

          break;
        }
    }
}

    据我所知，唯一可以降低引用计数的调用是：gtk_widget_unparent。

    以下是gtk_widget_unparent代码：

    /**
 * gtk_widget_unparent:
 * @widget: a #GtkWidget
 *
 * This function is only for use in widget implementations.
 * Should be called by implementations of the remove method
 * on #GtkContainer, to dissociate a child from the container.
 **/
void
gtk_widget_unparent (GtkWidget *widget)
{
  GtkWidgetPrivate *priv;
  GObjectNotifyQueue *nqueue;
  GtkWidget *toplevel;
  GtkWidget *old_parent;

  g_return_if_fail (GTK_IS_WIDGET (widget));

  priv = widget->priv;

  if (priv->parent == NULL)
    return;

  /* keep this function in sync with gtk_menu_detach() */

  gtk_widget_push_verify_invariants (widget);

  g_object_freeze_notify (G_OBJECT (widget));
  nqueue = g_object_notify_queue_freeze (G_OBJECT (widget), _gtk_widget_child_property_notify_context);

  toplevel = _gtk_widget_get_toplevel (widget);
  if (_gtk_widget_is_toplevel (toplevel))
    _gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);

  if (gtk_container_get_focus_child (GTK_CONTAINER (priv->parent)) == widget)
    gtk_container_set_focus_child (GTK_CONTAINER (priv->parent), NULL);

  gtk_widget_queue_draw_child (widget);

  /* Reset the width and height here, to force reallocation if we
   * get added back to a new parent. This won't work if our new
   * allocation is smaller than 1x1 and we actually want a size of 1x1...
   * (would 0x0 be OK here?)
   */
  priv->allocation.width = 1;
  priv->allocation.height = 1;

  if (_gtk_widget_get_realized (widget))
    {
      if (priv->in_reparent)
    gtk_widget_unmap (widget);
      else
    gtk_widget_unrealize (widget);
    }

  /* If we are unanchoring the child, we save around the toplevel
   * to emit hierarchy changed
   */
  if (priv->parent->priv->anchored)
    g_object_ref (toplevel);
  else
    toplevel = NULL;

  /* Removing a widget from a container restores the child visible
   * flag to the default state, so it doesn't affect the child
   * in the next parent.
   */
  priv->child_visible = TRUE;

  old_parent = priv->parent;
  priv->parent = NULL;

  /* parent may no longer expand if the removed
   * child was expand=TRUE and could therefore
   * be forcing it to.
   */
  if (_gtk_widget_get_visible (widget) &&
      (priv->need_compute_expand ||
       priv->computed_hexpand ||
       priv->computed_vexpand))
    {
      gtk_widget_queue_compute_expand (old_parent);
    }

  /* Unset BACKDROP since we are no longer inside a toplevel window */
  gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_BACKDROP);
  if (priv->context)
    gtk_style_context_set_parent (priv->context, NULL);
  gtk_css_node_set_parent (widget->priv->cssnode, NULL);

  _gtk_widget_update_parent_muxer (widget);

  g_signal_emit (widget, widget_signals[PARENT_SET], 0, old_parent);
  if (toplevel)
    {
      _gtk_widget_propagate_hierarchy_changed (widget, toplevel);
      g_object_unref (toplevel);
    }

  /* Now that the parent pointer is nullified and the hierarchy-changed
   * already passed, go ahead and unset the parent window, if we are unparenting
   * an embedded GtkWindow the window will become toplevel again and hierarchy-changed
   * will fire again for the new subhierarchy.
   */
  gtk_widget_set_parent_window (widget, NULL);

  g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_PARENT]);
  g_object_thaw_notify (G_OBJECT (widget));
  if (!priv->parent)
    g_object_notify_queue_clear (G_OBJECT (widget), nqueue);
  g_object_notify_queue_thaw (G_OBJECT (widget), nqueue);

  gtk_widget_pop_verify_invariants (widget);
  g_object_unref (widget);
}

    请注意，它做的最后一件事是g_object_unref

    据我所知，如果小部件是顶层的，g_object_ref则该函数g_object_unref在执行最终操作之前会执行内部操作g_object_unref。这些是平衡调用，因此可能不会发生变化。

    因此，粗略的结论是该功能确实可以清理一些东西。

    但是，这个函数有点复杂，调用了小部件上的许多 gtk_*函数，所以我无法判断最后一个调用是否仅仅是为了补偿其中一个gtk_*增加引用计数的调用。

    然而，这对我来说似乎很奇怪，所以我的[天真/简单的]结论是，最后的调用会g_object_unref执行您想要的操作。

    因此，在没有检查所有发出的各种呼叫的情况下，买者自慎……

    最好的方法可能是你自己做一些小技巧来获取引用计数的访问权限，并查看前后值。这可能是 UB（释放后使用），但对于一次性测试来说没问题。

    为了防止 UB，您可以将网格销毁调用包装在您自己的/人工的g_object_ref和g_object_unref对中。这将防止对象被回收，直到您 g_object_unref进行调用为止。

    • 1

相关问题