interface类似于C++中的抽象类。
分三部分：接口类，实现接口的类，测试函数。
这次的文件分了好几个：
my-iusb.h
#ifndef MY_IUSB_H
#define MY_IUSB_H
#include<glib-object.h>
#define MY_TYPE_IUSB (my_iusb_get_type())
#define MY_IUSB(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), MY_TYPE_IUSB, MyIUsb))
#define MY_IS_IUSB(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MY_TYPE_IUSB))
#define MY_IUSB_GET_INTERFACE(obj) (\
G_TYPE_INSTANCE_GET_INTERFACE((obj), MY_TYPE_IUSB, MyIUsbInterface))
typedef struct _MyIUsb MyIUsb;
typedef struct _MyIUsbInterface MyIUsbInterface;
struct _MyIUsbInterface {
GTypeInterface parent_interface;
gchar * (*read) (MyIUsb *self);
void (*write)(MyIUsb *self, const gchar *str);
// 这组指针就是接口协议
};
GType my_iusb_get_type(void);
// 声明接口
gchar *my_iusb_read(MyIUsb *self);
void my_iusb_write(MyIUsb *self, const gchar *str);
// 这是一个usb接口
// 这个接口既可以read又可以write，read只能返回字符串,write只能接受字符串
#endif
my-iusb.c
#include"my-udisk.h"
static void my_iusb_interface_init(MyIUsbInterface *iface);
G_DEFINE_TYPE_WITH_CODE(MyUdisk, my_udisk, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE(MY_TYPE_IUSB, my_iusb_interface_init));
static gchar *my_udisk_read(MyIUsb *iusb)
{
g_printf("%s %i.\n",__func__, __LINE__);
MyUdisk *udisk = MY_UDISK(iusb);
return udisk->data->str;
}
static void my_udisk_write(MyIUsb *iusb, const gchar *str)
{
MyUdisk *udisk = MY_UDISK(iusb);
g_string_assign(udisk->data, str);
g_printf("%s %i.\n",__func__, __LINE__);
}
static void my_udisk_init(MyUdisk *self)
{
self->data = g_string_new(NULL);
g_printf("%s %i.\n",__func__, __LINE__);
}
static void my_udisk_class_init(MyUdiskClass *self)
{
g_printf("%s %i.\n",__func__, __LINE__);
}
static void my_iusb_interface_init(MyIUsbInterface *iface)
{
iface->read = my_udisk_read;
iface->write = my_udisk_write;
g_printf("%s %i.\n",__func__, __LINE__);
}
上面的文件构成了接口，下面的文件是具体的使用者
my-udisk.h
#ifndef MY_UDISK_H
#define MY_UDISK_H
#include "my-iusb.h"
#define MY_TYPE_UDISK (my_udisk_get_type())
#define MY_UDISK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), MY_TYPE_UDISK, MyUdisk))
#define MY_IS_UDISK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MY_TYPE_UDISK))
#define MY_UDISK_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), MY_TYPE_UDISK, MyUdiskClass))
#define MY_IS_UDISK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MY_TYPE_UDISK))
#define MY_UDISK_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS((obj), MY_TYPE_UDISK, MyUdiskClass))
typedef struct _MyUdisk MyUdisk;
typedef struct _MyUdiskClass MyUdiskClass;
struct _MyUdisk {
GObject parent;
GString *data;
};
struct _MyUdiskClass {
GObjectClass parent_class;
};
GType my_udisk_get_type(void);
#endif
u-disk.c
#include "my-iusb.h"
G_DEFINE_INTERFACE (MyIUsb, my_iusb, G_TYPE_INVALID);
static void my_iusb_default_init(MyIUsbInterface *iface)
{ // 这是函数是宏G_DEFINE_INTERFACE展开后的一个函数
}
gchar *my_iusb_read(MyIUsb *self)
{
g_printf("%s %i.\n",__func__, __LINE__);
g_return_if_fail(MY_IS_IUSB(self));
MY_IUSB_GET_INTERFACE(self)->read(self);
}
void my_iusb_write(MyIUsb *self, const gchar *str)
{
g_printf("%s %i.\n",__func__, __LINE__);
g_return_if_fail(MY_IS_IUSB(self));
MY_IUSB_GET_INTERFACE(self)->write(self, str);
}
上述代码中，有几处需要留意的地方：
my_iusb_interface_init 函数声明必须要放在 G_DEFINE_TYPE_WITH_CODE 宏之前，因为这个宏的展开代码中需要使用这个函数；
G_DEFINE_TYPE_WITH_CODE 是文档 [2-5] 中出现过的 G_DEFINE_TYPE 宏的“扩展版本”，在本例中可以向 my_udisk_get_type 函数（即 MY_TYPE_UDISK 宏展开的那个函数）中插入 C 代码。在本例中，这个宏所插入的 C 代码是“G_IMPLEMENT_INTERFACE(MY_TYPE_IUSB,my_iusb_interface_init)”，其中 G_IMPLEMENT_INTERFACE 宏的作用是将接口添加到 MyUdisk 类中；
my_iusb_interface_init 函数的作用是表明 MyUdisk 类实现了 MyIUsb 所规定的接口。
接下来是main.c
#include "my-udisk.h"
int main(void)
{
g_type_init();
MyUdisk *udisk = g_object_new(MY_TYPE_UDISK, NULL);
my_iusb_write(MY_IUSB(udisk), "I am u-disk!");
gchar *data = my_iusb_read(MY_IUSB(udisk));
g_printf("%s\n\n",data);
g_printf("Is udisk a MyIUsb object?\n");
if(MY_IS_IUSB(udisk)) {
g_printf("Yes!\n");
} else {
g_printf("No!\n");
}
g_printf("\nIs udisk a MyUdisk object?\n");
if (MY_IS_UDISK(udisk)) {
g_printf("Yes!\n");
} else {
g_printf("No!\n");
}
return 0;
}
最后放上MAKEFILE
all:
gcc -g `pkg-config --cflags --libs gobject-2.0` my-iusb.c my-udisk.c main.c -o test
输入结果如下：
my_udisk_class_init 30.
my_iusb_interface_init 37.
my_udisk_init 25.
my_iusb_write 18.
my_udisk_write 19.
my_iusb_read 11.
my_udisk_read 10.
I am u-disk!
Is udisk a MyIUsb object?
Yes!
Is udisk a MyUdisk object?
Yes!
下面我要粘贴的是原作者写的： 经常要用到并且需要自己定义的宏
对于 GTypeInterface 的子类化，在声明类的时候，在头文件中直接插入类似下面的一组宏定义：
#define P_TYPE_IT (p_t_get_type ())
#define P_IT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), P_TYPE_IT, PIt))
#define P_IS_IT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), P_TYPE_IT))
#define P_IT_GET_INTERFACE(obj) \
(G_TYPE_INSTANCE_GET_INTERFACE ((obj), P_TYPE_IT, PItInterface))
P_TYPE_IT：仅在接口实现时使用一次，用于向 GObject 库的类型系统注册 PIT 接口；
P_IT (obj)：用于将 obj 对象的类型强制转换为 P_IT 接口的实例结构体类型；
P_IS_IT (obj)：用于判断 obj 对象的类型是否为 P_IT 接口的实例结构体类型；
P_IT_GET_INTERFACE(obj)：获取 obj 对象对应的 P_IT 接口的类结构体类型。
---------------------
作者：DawnRayYang
来源：CSDN
原文：https://blog.csdn.net/xbl1986/article/details/6722783?utm_source=copy
版权声明：本文为博主原创文章，转载请附上博文链接！
另一个例子：
本部分介绍如何定义一个接口，个人感觉介绍GObject中如何使用接口的资料还是比较少的。。。。XD
一般的类的继承可以分为两种，一种就是传统的，另一种则是接口形式的。
在使用方面有些差异，前者调用一个类的成员，而后者则将某个类转换成抽象的接口，只使用接口中定义的方法。
在GObject中，按照个人的理解。所谓接口还是一个类结构，只不过这个类结构不被实例化，但其class结构还是要定义的。
假设我们定义一个名为Ihuman的接口，里面定义名为speak的方法。
#define JC_TYPE_IHUMAN (jc_ihuman_get_type ())
#define JC_IHUMAN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), JC_TYPE_IHUMAN, JcIhuman))
#define JC_IS_IHUMAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), JC_TYPE_IHUMAN))
#define JC_IHUMAN_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), JC_TYPE_IHUMAN, JcIhumanInterface))
宏定义少了几个，因为不需要定义实例结构，这里面INTERFACE结构可以与前文中CLASS结构相对应.
typedef struct _JcIhuman JcIhuman; /* dummy object */
typedef struct _JcIhumanInterface JcIhumanInterface;
注意我们typedef了JcIhuman，但实际上并没有真正的定义，我们仅仅需要定义JcIhumanInterface，如下，
struct _JcIhumanInterface
{
GTypeInterface parent_iface;
void (*speak) ();
};
Interface中我们自己要定义的只有一个指向函式的指针
当然还是少不了一个类型获取函式和一个对外的函式.
GType jc_ihuman_get_type (void);
void jc_people_talk (JcIhuman *self);
下面看如何实现，
GType
jc_ihuman_get_type (void)
{
static GType iface_type = 0;
if (iface_type == 0)
{
static const GTypeInfo info = {
sizeof (JcIhumanInterface),
NULL, /* base_init */
NULL, /* base_finalize */
};
iface_type = g_type_register_static (G_TYPE_INTERFACE, "JcIhuman",&info, 0);
}
return iface_type;
}
在GTypeInfo中有两个NULL,分别对应的是base_init和base_finalize
前文中有简单的介绍一个类初始化和终结的过程。
void
jc_people_talk (JcIhuman *self)
{
g_return_if_fail (JC_IS_IHUMAN (self));
JC_IHUMAN_GET_INTERFACE (self)->speak ();
}
如果在调用时，我们传入的肯定是一个实现了该接口的类的实例。所以在调用的时候要使用宏定义JC_HUMAN_GET_INTERFACE.
我们看到上面的结构中并没有定义类似class_init的结构，但并不意味就不定义了，在接口的实现时还是要定义一个名为interface_init结构。
假设我们定义的Boy类要实现speak这一Ihuman定义的接口，要增加如下的代码
G_DEFINE_TYPE_WITH_CODE (JcBoy, jc_boy, JC_TYPE_BABY,//);
G_IMPLEMENT_INTERFACE (JC_TYPE_IHUMAN,
jc_ihuman_interface_init));
这里就不用G_DEFINE_TYPE了，而是使用G_DEFINE_TYPE_WITH_CODE，而这两个宏本身都是对其它宏的简化，因为前文简单介绍过，这里就不展开了。
其中G_IMPLEMENT_INTERFACE是声明这个类要实现接口，并且指定了接口初始化的函式指针，其展开后如下，
#define G_IMPLEMENT_INTERFACE(TYPE_IFACE, iface_init) { \
const GInterfaceInfo g_implement_interface_info = { \
(GInterfaceInitFunc) iface_init, NULL, NULL \
}; \
g_type_add_interface_static (g_define_type_id, TYPE_IFACE, &g_implement_interface_info); \
}
下面看接口实现的函式
static void speak()
{
g_print("la la la ... haha ! I'm a boy!\n");
}
static void
jc_ihuman_interface_init(JcIhumanInterface *iface)
{
iface->speak =speak;
}
interface_init其中就是简单做了一个指针的赋值，仅此而已。
至此一个接口的定义与实现就完成了。
而调用起来也是比较容易的，
JcBoy *boy = g_object_new (JC_TYPE_BOY, NULL);
jc_people_talk(boy);
扫一扫
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
