九、接口 | 李尔阳主页

接口类似于抽象类。接口定义了虚拟函数，这些函数预期会被另一个可实例化对象中的函数覆盖。

本节提供了一个简单的例子，TComparable。TComparable 是一个接口。它定义了比较的函数，这些函数包括：

t_comparable_cmp(self, other)：它比较 self 和 other。第一个参数 self 是运行 t_comparable_cmp 的实例。第二个参数 other 是另一个实例。这个函数需要在实现了该接口的对象中被覆盖。
- 如果 self 等于 other，t_comparable_cmp 返回 0。
- 如果 self 大于 other，t_comparable_cmp 返回 1。
- 如果 self 小于 other，t_comparable_cmp 返回 -1。
- 如果发生错误，t_comparable_cmp 返回 -2。
t_comparable_eq(self, other)：如果 self 等于 other，则返回 TRUE。否则返回 FALSE。需要注意的是，即使发生错误也会返回 FALSE。
t_comparable_gt(self, other)：如果 self 大于 other，则返回 TRUE。否则返回 FALSE。
t_comparable_lt(self, other)：如果 self 小于 other，则返回 TRUE。否则返回 FALSE。
t_comparable_ge(self, other)：如果 self 大于或等于 other，则返回 TRUE。否则返回 FALSE。
t_comparable_le(self, other)：如果 self 小于或等于 other，则返回 TRUE。否则返回 FALSE。

数字和字符串是可比较的。TInt、TDouble 和 TStr 实现了 TComparable 接口，因此它们可以使用上述函数。此外，TNumStr 也可以使用这些函数，因为它是 TStr 的子类。

例如，

TInt *i1 = t_int_new_with_value (10);
TInt *i2 = t_int_new_with_value (20);
t_comparable_eq (T_COMPARABLE (i1), T_COMPARABLE (i2)); /* => FALSE */
t_comparable_lt (T_COMPARABLE (i1), T_COMPARABLE (i2)); /* => TRUE */

接口和抽象类之间的区别是什么？在抽象类中的虚拟函数由其后代类中的函数覆盖。在接口中的虚拟函数可以由任何类中的函数覆盖。比较一下 TNumber 和 TComparable。

函数 t_number_add 在 TIntClass 和 TDoubleClass 中被覆盖。它不能在 TStrClass 中被覆盖，因为 TStr 不是 TNumber 的后代。
函数 t_comparable_cmp 在 TIntClass、TDoubleClass 和 TStrClass 中被覆盖。

1 TComparable 接口

定义接口与定义对象类似。

使用 G_DECLARE_INTERFACE 代替 G_DECLARE_FINAL_TYPE。
使用 G_DEFINE_INTERFACE 代替 G_DEFINE_TYPE。

1.1 头文件 tcomparable.h

现在让我们看看头文件。

#pragma once

#include <glib-object.h>

#define T_TYPE_COMPARABLE  (t_comparable_get_type ())
G_DECLARE_INTERFACE (TComparable, t_comparable, T, COMPARABLE, GObject)
/* 这其实是一个类结构体，接口没有实例结构体（压根就没有实例结构体的定义） */
struct _TComparableInterface {
 GTypeInterface parent; /* 注意：第一个成员是 GTypeInterface parent */
 /* 信号 */
 void (*arg_error) (TComparable *self);
 /* 虚函数 */
 int (*cmp) (TComparable *self, TComparable *other);
};

/* t_comparable_cmp */
/* if self > other, then returns 1 */
/* if self = other, then returns 0 */
/* if self < other, then returns -1 */
/* if error happens, then returns -2 */

int
t_comparable_cmp (TComparable *self, TComparable *other);

gboolean
t_comparable_eq (TComparable *self, TComparable *other);

gboolean
t_comparable_gt (TComparable *self, TComparable *other);

gboolean
t_comparable_lt (TComparable *self, TComparable *other);

gboolean
t_comparable_ge (TComparable *self, TComparable *other);

gboolean
t_comparable_le (TComparable *self, TComparable *other);

6: G_DECLARE_INTERFACE宏。最后一个参数是接口的先决条件。TComparable的先决条件是GObject。因此，除了GObject的派生类之外，例如GVariant，不能实现TComparable。先决条件是接口或类的GType。此宏扩展为：

/************************************G_DECLARE_INTERFACE宏展开*********************START**********************/

GType t_comparable_get_type (void);

# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"
#pragma GCC diagnostic push
# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"

# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"

typedef struct _TComparable TComparable; 
typedef struct _TComparableInterface TComparableInterface; 
typedef TComparable *TComparable_autoptr; 
typedef GList *TComparable_listautoptr; 
typedef GSList *TComparable_slistautoptr; 
typedef GQueue *TComparable_queueautoptr;

# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"
#pragma GCC diagnostic push
# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"

# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"

static __attribute__ ((__unused__)) inline void 
glib_autoptr_clear_TComparable (TComparable *_ptr) { 
  if (_ptr) (glib_autoptr_clear_GObject) ((GObject *) _ptr); 
} 

static __attribute__ ((__unused__)) inline void 
glib_autoptr_cleanup_TComparable (TComparable **_ptr) { 
  glib_autoptr_clear_TComparable (*_ptr); 
} 

static __attribute__ ((__unused__)) inline void 
glib_listautoptr_cleanup_TComparable (GList **_l) { 
  g_list_free_full (*_l, (GDestroyNotify) (void(*)(void)) glib_autoptr_clear_GObject); 
} 

static __attribute__ ((__unused__)) inline void 
glib_slistautoptr_cleanup_TComparable (GSList **_l) { 
  g_slist_free_full (*_l, (GDestroyNotify) (void(*)(void)) glib_autoptr_clear_GObject); 
} 
static __attribute__ ((__unused__)) inline void 
glib_queueautoptr_cleanup_TComparable (GQueue **_q) { 
  if (*_q) g_queue_free_full (*_q, (GDestroyNotify) (void(*)(void)) glib_autoptr_clear_GObject); 
}

# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"
#pragma GCC diagnostic pop
# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"
__attribute__ ((__unused__)) static inline TComparable * 
T_COMPARABLE (gpointer ptr) { 
  return (((TComparable*) (void *) g_type_check_instance_cast ((GTypeInstance*) (ptr), (t_comparable_get_type ())))); 
} 

__attribute__ ((__unused__)) static inline gboolean 
T_IS_COMPARABLE (gpointer ptr) { 
  return ((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (ptr); 
                            GType __t = (t_comparable_get_type ()); 
                            gboolean __r; 
                            if (!__inst) __r = (0); 
                            else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); 
                            else __r = g_type_check_instance_is_a (__inst, __t); __r; }))); 
} 

__attribute__ ((__unused__)) static inline TComparableInterface * 
T_COMPARABLE_GET_IFACE (gpointer ptr) { 
  return (((TComparableInterface*) g_type_interface_peek (((GTypeInstance*) (ptr))->g_class, (t_comparable_get_type ())))); 
}

# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"
#pragma GCC diagnostic pop
# 4 "/home/lieryang/Desktop/gobject-study/section-two/sec9/interface.c"


/************************************G_DECLARE_INTERFACE宏展开*********************END**********************/

声明 GType t_comparable_get_type (void);
定义 typedef struct _TComparableInterface TComparableInterface
定义 T_COMPARABLE()宏。它将一个实例转换为TComparable类型。
定义 T_IS_COMPARABLE()宏。它检查实例的类型是否为T_TYPE_COMPARABLE。
定义 T_COMPARABLE_GET_IFACE()宏。它获取给定作为参数的实例的接口。

8-14: TComparableInterface结构。这类似于类结构。第一个成员是父接口。TComparableInterface的父接口是GTypeInterface。GTypeInterface是所有接口类型的基类。它类似于是GTypeClass，它是所有类类型的基类。GTypeClass是结构GObjectClass的第一个成员。请参阅gobject.h。请注意，GObjectClass与struct _GObjectClass相同)。
```
/* GTypeInterface有两个成员，一个是接口类型id，另一个是实例 */
struct _GTypeInterface
{
  /*< private >*/
  GType g_type;         /* iface type */
  GType g_instance_type;
};
```
下一个成员是指向“arg-error”信号的默认信号处理程序arg_error的指针。当比较函数的第二个参数不合适时，将触发此信号。例如，如果self是TInt，other是TStr，它们都是Comparable实例。但它们不能进行比较。这是因为other不是TNumber。最后一个成员cmp是指向比较方法的指针。这是一个虚函数，预计将由实现接口的对象中的函数覆盖。
22-38: 公共函数。

1.2 源文件 tcomparable.c

C文件tcomparable.c如下所示：

#include "tcomparable.h"

static guint t_comparable_signal;

G_DEFINE_INTERFACE (TComparable, t_comparable, G_TYPE_OBJECT)

static void
arg_error_default_cb (TComparable *self) {
 g_printerr ("\nTComparable: argument error.\n");
}

static void
t_comparable_default_init (TComparableInterface *iface) {
 /* virtual function */
 iface->cmp = NULL;
 /* argument error signal */
 iface->arg_error = arg_error_default_cb;
 t_comparable_signal =
 g_signal_new ("arg-error",
               T_TYPE_COMPARABLE,
               G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
               G_STRUCT_OFFSET (TComparableInterface, arg_error),
               NULL /* accumulator */,
               NULL /* accumulator data */,
               NULL /* C marshaller */,
               G_TYPE_NONE /* return_type */,
               0     /* n_params */
               );
}

int
t_comparable_cmp (TComparable *self, TComparable *other) {
 g_return_val_if_fail (T_IS_COMPARABLE (self), -2);

 TComparableInterface *iface = T_COMPARABLE_GET_IFACE (self);
 
 return (iface->cmp == NULL ? -2 : iface->cmp (self, other));
}

gboolean
t_comparable_eq (TComparable *self, TComparable *other) {
 return (t_comparable_cmp (self, other) == 0);
}

gboolean
t_comparable_gt (TComparable *self, TComparable *other) {
 return (t_comparable_cmp (self, other) == 1);
}

gboolean
t_comparable_lt (TComparable *self, TComparable *other) {
 return (t_comparable_cmp (self, other) == -1);
}

gboolean
t_comparable_ge (TComparable *self, TComparable *other) {
 int result = t_comparable_cmp (self, other);
 return (result == 1 || result == 0);
}

gboolean
t_comparable_le (TComparable *self, TComparable *other) {
 int result = t_comparable_cmp (self, other);
 return (result == -1 || result == 0);
}

5： G_DEFINE_INTERFACE宏。第三个参数是前提条件的类型。此宏扩展为：

/************************************G_DEFINE_INTERFACE宏展开*********************START**********************/
static void t_comparable_default_init (TComparableInterface *klass);
GType t_comparable_get_type (void) { 
  static gsize static_g_define_type_id = 0; 
  if ((__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id) == sizeof (gpointer), "Expression evaluates to false"); 
    (void) (0 ? (gpointer) *(&static_g_define_type_id) : ((void *)0)); 
    (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id) == sizeof (gpointer), "Expression evaluates to false"); 
    __typeof__ (*(&static_g_define_type_id)) gapg_temp_newval; 
    __typeof__ ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id); 
    __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5); 
    gapg_temp_newval; 
    })) && g_once_init_enter (&static_g_define_type_id)); 
  }))) {
    
    GType g_define_type_id = g_type_register_static_simple (((GType) ((2) << (2))), 
                                                            g_intern_static_string ("TComparable"), 
                                                            sizeof (TComparableInterface), 
                                                            (GClassInitFunc)(void (*)(void)) t_comparable_default_init, 
                                                            0, 
                                                            (GInstanceInitFunc) ((void *)0), 
                                                            (GTypeFlags) 0); 
      
    if (((GType) ((20) << (2))) != ((GType) ((0) << (2)))) 
      g_type_interface_add_prerequisite (g_define_type_id, ((GType) ((20) << (2)))); 
        
      { {;;} } 
        
      (__extension__ ({ 
        _Static_assert (sizeof *(&static_g_define_type_id) == sizeof (gpointer), "Expression evaluates to false"); 
        0 ? (void) (*(&static_g_define_type_id) = (g_define_type_id)) : (void) 0; g_once_init_leave ((&static_g_define_type_id), (gsize) (g_define_type_id)); 
      })); 
  } 
  return static_g_define_type_id; 
}
/************************************G_DEFINE_INTERFACE宏展开*********************END**********************/

声明 t_comparable_default_init()。
定义 t_comparable_get_type()。

7-10: arg_error_default_cb是”arg-error”信号的默认信号处理程序。
12-29: t_comparable_default_init函数。此函数类似于类初始化函数。它初始化TComparableInterface结构。
15: 将cmp赋值为NULL。因此，在实现类覆盖它之前，比较方法不起作用。
17: 设置”arg-error”信号的默认信号处理程序。
18-28: 创建”arg-error”信号。
31-38: 函数t_comparable_cmp。它首先检查self的类型。如果它不可比较，它会记录错误消息并返回-2（错误）。如果iface->cmp为NULL（这意味着类方法还没有被覆盖），则返回-2。否则，它调用类方法并返回类方法返回的值。
40-65: 公共函数。这五个函数都基于 t_comparable_cmp 。因此，它们不需要被覆盖。例如，t_comparable_eq只是调用t_comparable_cmp。如果t_comparable_cmp返回零，它返回TRUE。否则，它返回FALSE。

这个程序使用信号向用户提供参数类型错误信息。这种错误通常是程序错误，而不是运行时错误。使用信号报告程序错误并不是一个好方法。最好的方法是使用g_return_if_fail。我之所以使用这个信号，只是想演示如何在接口中实现信号。

2 Implementing interface

TInt、TDouble 和 TStr 实现了 TComparable。首先看一下 TInt。头文件与之前相同。实现是在 C 文件中编写的。

2.1 源文件 tint.c

tint.c 如下：

#include "../tnumber/tnumber.h"
#include "../tnumber/tint.h"
#include "../tnumber/tdouble.h"
#include "tcomparable.h"

enum {
 PROP_0,
 PROP_INT,
 N_PROPERTIES
};

static GParamSpec *int_properties[N_PROPERTIES] = {NULL, };

struct _TInt {
 TNumber parent;
 int value;
};

static void t_comparable_interface_init (TComparableInterface *iface);

G_DEFINE_TYPE_WITH_CODE (TInt, t_int, T_TYPE_NUMBER,
                        G_IMPLEMENT_INTERFACE (T_TYPE_COMPARABLE, t_comparable_interface_init))

static int
t_int_comparable_cmp (TComparable *self, TComparable *other) {
 if (! T_IS_NUMBER (other)) {
   g_signal_emit_by_name (self, "arg-error");
   return -2;
 }

 int i;
 double s, o;

 s = (double) T_INT (self)->value;
 if (T_IS_INT (other)) {
   g_object_get (other, "value", &i, NULL);
   o = (double) i;
 } else
   g_object_get (other, "value", &o, NULL);
 if (s > o)
   return 1;
 else if (s == o)
   return 0;
 else if (s < o)
   return -1;
 else /* This can't happen. */
   return -2;
}

static void
t_comparable_interface_init (TComparableInterface *iface) {
 iface->cmp = t_int_comparable_cmp;
}

static void
t_int_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) {
 TInt *self = T_INT (object);

 if (property_id == PROP_INT)
   self->value = g_value_get_int (value);
 else
   G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
t_int_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) {
 TInt *self = T_INT (object);

 if (property_id == PROP_INT)
   g_value_set_int (value, self->value);
 else
   G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
t_int_init (TInt *self) {
}

/* arithmetic operator */
/* These operators create a new instance and return a pointer to it. */
#define t_int_binary_op(op) \
 int i; \
 double d; \
 if (T_IS_INT (other)) { \
   g_object_get (T_INT (other), "value", &i, NULL); \
   return  T_NUMBER (t_int_new_with_value (T_INT(self)->value op i)); \
 } else { \
   g_object_get (T_DOUBLE (other), "value", &d, NULL); \
   return  T_NUMBER (t_int_new_with_value (T_INT(self)->value op (int) d)); \
 }

static TNumber *
t_int_add (TNumber *self, TNumber *other) {
 g_return_val_if_fail (T_IS_INT (self), NULL);

 t_int_binary_op (+)
}

static TNumber *
t_int_sub (TNumber *self, TNumber *other) {
 g_return_val_if_fail (T_IS_INT (self), NULL);

 t_int_binary_op (-)
}

static TNumber *
t_int_mul (TNumber *self, TNumber *other) {
 g_return_val_if_fail (T_IS_INT (self), NULL);

 t_int_binary_op (*)
}

static TNumber *
t_int_div (TNumber *self, TNumber *other) {
 g_return_val_if_fail (T_IS_INT (self), NULL);

 int i;
 double d;

 if (T_IS_INT (other)) {
   g_object_get (T_INT (other), "value", &i, NULL);
   if (i == 0) {
     g_signal_emit_by_name (self, "div-by-zero");
     return NULL;
   } else
     return  T_NUMBER (t_int_new_with_value (T_INT(self)->value / i));
 } else {
   g_object_get (T_DOUBLE (other), "value", &d, NULL);
   if (d == 0) {
     g_signal_emit_by_name (self, "div-by-zero");
     return NULL;
   } else
     return  T_NUMBER (t_int_new_with_value (T_INT(self)->value / (int)  d));
 }
}

static TNumber *
t_int_uminus (TNumber *self) {
 g_return_val_if_fail (T_IS_INT (self), NULL);

 return T_NUMBER (t_int_new_with_value (- T_INT(self)->value));
}

static char *
t_int_to_s (TNumber *self) {
 g_return_val_if_fail (T_IS_INT (self), NULL);

 int i;

 g_object_get (T_INT (self), "value", &i, NULL); 
 return g_strdup_printf ("%d", i);
}

static void
t_int_class_init (TIntClass *class) {
 TNumberClass *tnumber_class = T_NUMBER_CLASS (class);
 GObjectClass *gobject_class = G_OBJECT_CLASS (class);

 /* override virtual functions */
 tnumber_class->add = t_int_add;
 tnumber_class->sub = t_int_sub;
 tnumber_class->mul = t_int_mul;
 tnumber_class->div = t_int_div;
 tnumber_class->uminus = t_int_uminus;
 tnumber_class->to_s = t_int_to_s;

 gobject_class->set_property = t_int_set_property;
 gobject_class->get_property = t_int_get_property;
 int_properties[PROP_INT] = g_param_spec_int ("value", "val", "Integer value", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE);
 g_object_class_install_properties (gobject_class, N_PROPERTIES, int_properties);
}

TInt *
t_int_new_with_value (int value) {
 TInt *i;

 i = g_object_new (T_TYPE_INT, "value", value, NULL);
 return i;
}

TInt *
t_int_new (void) {
 TInt *i;

 i = g_object_new (T_TYPE_INT, NULL);
 return i;
}

4：需要包含 TComparable 的头文件。
19：声明 t_comparable_interface_init() 函数。这个声明必须在 G_DEFINE_TYPE_WITH_CODE 宏之前完成。
21-22：G_DEFINE_TYPE_WITH_CODE 宏。最后一个参数是 G_IMPLEMENT_INTERFACE 宏。G_IMPLEMENT_INTERFACE 的第二个参数是 t_comparable_interface_init。这两个宏展开为：
- 声明 t_int_class_init()。
- 声明 t_int_init()。
- 定义静态变量 t_int_parent_class，它指向父类的类结构。
- 定义 t_int_get_type()。此函数包含 g_type_register_static_simple() 和 g_type_add_interface_static()。g_type_register_static_simple() 是 g_type_register_static() 的便捷版本，它将 TInt 类型注册到类型系统中。g_type_add_interface_static() 将接口类型添加到实例类型中。在 GObject 参考手册的 Interfaces 一节中有一个很好的例子。如果你想知道如何不使用宏来编写代码，请参见 tint_without_macro.c。
24-48：t_int_comparable_cmp 是一个比较 TInt 实例和 TNumber 实例的函数。
26-29：检查 other 的类型。如果参数类型不是 TNumber，则使用 g_signal_emit_by_name 发出 “arg-error” 信号。
34：将 self 转换为 double 类型。
35-39：获取 other 的值，如果它是 TInt，则将值转换为 double。
40-47：比较 s 和 o，返回 1、0、-1 和 -2。
50-53：t_comparable_interface_init。这个函数在 TInt 的初始化过程中被调用。函数 t_int_comparable_cmp 被分配给 iface->cmp。

tdouble.c 与 tint.c 几乎相同。这两个对象可以比较，因为在比较前 int 被转换为 double。

2.2 源文件 tstr.c

#include "../tstr/tstr.h"
#include "tcomparable.h"

enum {
 PROP_0,
 PROP_STRING,
 N_PROPERTIES
};

static GParamSpec *str_properties[N_PROPERTIES] = {NULL, };

typedef struct {
 char *string;
} TStrPrivate;

static void t_comparable_interface_init (TComparableInterface *iface);

G_DEFINE_TYPE_WITH_CODE (TStr, t_str, G_TYPE_OBJECT,
                        G_ADD_PRIVATE (TStr)
                        G_IMPLEMENT_INTERFACE (T_TYPE_COMPARABLE, t_comparable_interface_init))

static void
t_str_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) {
 TStr *self = T_STR (object);

/* The returned value of the function g_value_get_string can be NULL. */
/* The function t_str_set_string calls a class method, */
/* which is expected to rewrite in the descendant object. */
 if (property_id == PROP_STRING)
   t_str_set_string (self, g_value_get_string (value));
 else
   G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
t_str_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) {
 TStr *self = T_STR (object);
 TStrPrivate *priv = t_str_get_instance_private (self);

/* The second argument of the function g_value_set_string can be NULL. */
 if (property_id == PROP_STRING)
   g_value_set_string (value, priv->string);
 else
   G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

/* This function just set the string. */
/* So, no notify signal is emitted. */
static void
t_str_real_set_string (TStr *self, const char *s) {
 TStrPrivate *priv = t_str_get_instance_private (self);

 if (priv->string)
   g_free (priv->string);
 priv->string = g_strdup (s);
}

static void
t_str_finalize (GObject *object) {
 TStr *self = T_STR (object);
 TStrPrivate *priv = t_str_get_instance_private (self);

 if (priv->string)
   g_free (priv->string);
 G_OBJECT_CLASS (t_str_parent_class)->finalize (object);
}

static int
t_str_comparable_cmp (TComparable *self, TComparable *other) {
 if (! T_IS_STR (other)) {
   g_signal_emit_by_name (self, "arg-error");
   return -2;
 }

 char *s, *o;
 int result;

 s = t_str_get_string (T_STR (self));
 o = t_str_get_string (T_STR (other));

 if (strcmp (s, o) > 0)
   result = 1;
 else if (strcmp (s, o) == 0)
   result = 0;
 else if (strcmp (s, o) < 0)
   result = -1;
 else /* This can't happen. */
   result = -2;
 g_free (s);
 g_free (o);
 return result;
}

static void
t_comparable_interface_init (TComparableInterface *iface) {
 iface->cmp = t_str_comparable_cmp;
}

static void
t_str_init (TStr *self) {
 TStrPrivate *priv = t_str_get_instance_private (self);

 priv->string = NULL;
}

static void
t_str_class_init (TStrClass *class) {
 GObjectClass *gobject_class = G_OBJECT_CLASS (class);

 gobject_class->finalize = t_str_finalize;
 gobject_class->set_property = t_str_set_property;
 gobject_class->get_property = t_str_get_property;
 str_properties[PROP_STRING] = g_param_spec_string ("string", "str", "string", "", G_PARAM_READWRITE);
 g_object_class_install_properties (gobject_class, N_PROPERTIES, str_properties);

 class->set_string = t_str_real_set_string;
}

/* setter and getter */
void
t_str_set_string (TStr *self, const char *s) {
 g_return_if_fail (T_IS_STR (self));
 TStrClass *class = T_STR_GET_CLASS (self);

/* The setter calls the class method 'set_string', */
/* which is expected to be overridden by the descendant TNumStr. */
/* Therefore, the behavior of the setter is different between TStr and TNumStr. */
 class->set_string (self, s);
}

char *
t_str_get_string (TStr *self) {
 g_return_val_if_fail (T_IS_STR (self), NULL);
 TStrPrivate *priv = t_str_get_instance_private (self);

 return g_strdup (priv->string);
}

TStr *
t_str_concat (TStr *self, TStr *other) {
 g_return_val_if_fail (T_IS_STR (self), NULL);
 g_return_val_if_fail (T_IS_STR (other), NULL);

 char *s1, *s2, *s3;
 TStr *str;

 s1 = t_str_get_string (self);
 s2 = t_str_get_string (other);
 if (s1 && s2)
   s3 = g_strconcat (s1, s2, NULL);
 else if (s1)
   s3 = g_strdup (s1);
 else if (s2)
   s3 = g_strdup (s2);
 else
   s3 = NULL;
 str = t_str_new_with_string (s3);
 if (s1) g_free (s1);
 if (s2) g_free (s2);
 if (s3) g_free (s3);
 return str;
}

/* create a new TStr instance */
TStr *
t_str_new_with_string (const char *s) {
 return T_STR (g_object_new (T_TYPE_STR, "string", s, NULL));
}

TStr *
t_str_new (void) {
 return T_STR (g_object_new (T_TYPE_STR, NULL));
}

16：声明了 t_comparable_interface_init 函数。在 G_DEFINE_TYPE_WITH_CODE 宏之前需要声明该函数。
18-20：G_DEFINE_TYPE_WITH_CODE 宏。因为 TStr 是可派生类型，所以需要其私有区域（TStrPrivate）。G_ADD_PRIVATE 宏创建了私有区域。注意 G_ADD_PRIVATE 宏后面没有逗号。
68-92：t_str_comparable_cmp 函数。
70-73：检查 other 的类型。如果它不是 TStr，则发出 “arg-error” 信号。
78-79：从 TStr 对象 self 和 other 中获取字符串 s 和 o。
81-88：使用 C 标准函数 strcmp 比较 s 和 o。
89-90：释放 s 和 o。
91：返回结果。
94-97：t_comparable_interface_init 函数。它用 t_str_comparable_cmp 覆盖了 iface->comp。

TStr 可以与 TStr 比较，但不能与 TInt 或 TDouble 比较。通常，比较只在两个同类型实例之间可用。

TNumStr 本身没有实现 TComparable。但它是 TStr 的子类，所以它是可比较的。比较基于字母顺序。所以，”a” 大于 “b”，”three” 大于 “two”。

3 Test program

main.c 是一个测试程序

3.1 main.c

#include <glib-object.h>
#include "tcomparable.h"
#include "../tnumber/tnumber.h"
#include "../tnumber/tint.h"
#include "../tnumber/tdouble.h"
#include "../tstr/tstr.h"

static void
t_print (const char *cmp, TComparable *c1, TComparable *c2) {
 char *s1, *s2;
 TStr *ts1, *ts2, *ts3;

 ts1 = t_str_new_with_string("\"");
 if (T_IS_NUMBER (c1))
   s1 = t_number_to_s (T_NUMBER (c1));
 else if (T_IS_STR (c1)) {
   ts2 = t_str_concat (ts1, T_STR (c1));
   ts3 = t_str_concat (ts2, ts1);
   s1 = t_str_get_string (T_STR (ts3));
   g_object_unref (ts2);
   g_object_unref (ts3);
 } else {
   g_print ("c1 isn't TInt, TDouble nor TStr.\n");
   return;
 }
 if (T_IS_NUMBER (c2))
   s2 = t_number_to_s (T_NUMBER (c2));
 else if (T_IS_STR (c2)) {
   ts2 = t_str_concat (ts1, T_STR (c2));
   ts3 = t_str_concat (ts2, ts1);
   s2 = t_str_get_string (T_STR (ts3));
   g_object_unref (ts2);
   g_object_unref (ts3);
 } else {
   g_print ("c2 isn't TInt, TDouble nor TStr.\n");
   return;
 }
 g_print ("%s %s %s.\n", s1, cmp, s2);
 g_object_unref (ts1);
 g_free (s1);
 g_free (s2);
}    

static void
compare (TComparable *c1, TComparable *c2) {
 if (t_comparable_eq (c1, c2))
   t_print ("equals", c1, c2);
 else if (t_comparable_gt (c1, c2))
   t_print ("is greater than", c1, c2);
 else if (t_comparable_lt (c1, c2))
   t_print ("is less than", c1, c2);
 else if (t_comparable_ge (c1, c2))
   t_print ("is greater than or equal to", c1, c2);
 else if (t_comparable_le (c1, c2))
   t_print ("is less than or equal to", c1, c2);
 else
   t_print ("can't compare to", c1, c2);
}

int
main (int argc, char **argv) {
 const char *one = "one";
 const char *two = "two";
 const char *three = "three";
 TInt *i;
 TDouble *d;
 TStr *str1, *str2, *str3;

 i = t_int_new_with_value (124);
 d = t_double_new_with_value (123.45);
 str1 = t_str_new_with_string (one);
 str2 = t_str_new_with_string (two);
 str3 = t_str_new_with_string (three);

 compare (T_COMPARABLE (i), T_COMPARABLE (d));
 compare (T_COMPARABLE (str1), T_COMPARABLE (str2));
 compare (T_COMPARABLE (str2), T_COMPARABLE (str3));
 compare (T_COMPARABLE (i), T_COMPARABLE (str1));

 g_object_unref (i);
 g_object_unref (d);
 g_object_unref (str1);
 g_object_unref (str2);
 g_object_unref (str3);

 return 0;
}

8-42：函数 t_print 有三个参数，并构建一个输出字符串，然后将其显示在显示器上。在构建输出时，字符串被双引号包围。
44-58：函数 compare 比较两个 TComparable 对象，并调用 t_print 来显示结果。
60-87：main 函数。
69-73：创建 TInt、TDouble 和三个 TStr 实例。它们被赋予了值。
75：比较 TInt 和 TDouble。
76-77：比较两个 TStr。
78：将 TInt 与 TStr 比较。这会产生一个 “arg-error”。
80-84：释放对象。

4 Compilation and execution

改变目录到 /assets/GObjectStudy/202311/09_GObject/tcomparable/

$ cd ./assets/GObjectStudy/202311/09_GObject/tcomparable/
$ meson setup _build
$ ninja -C _build

执行

$ _build/tcomparable
124 is greater than 123.450000.
"one" is less than "two".
"two" is greater than "three".

TComparable: argument error.

TComparable: argument error.

TComparable: argument error.

TComparable: argument error.

TComparable: argument error.
124 can't compare to "one".

5 Build an interface without macros

我们使用了如 G_DECLARE_INTERFACE、G_DEFINE_INTERFACE 等宏来构建接口。并使用 G_DEFINE_TYPE_WITH_CODE 来实现接口。我们也可以不使用宏来构建它。在 tcomparable 目录中有三个文件。

tcomparable_without_macro.h
tcomparable_without_macro.c
tint_without_macro.c

它们不使用宏。相反，它们直接将接口或接口的实现注册到类型系统中。如果你想了解这方面的内容，可以查看 /assets/GObjectStudy/202311/09_GObject/tcomparable/ 中的源文件。

参考

Interface：https://github.com/ToshioCP/Gobject-tutorial/blob/main/gfm/sec9.md