3.派生类和抽象类

已于 2023-04-22 15:46:08 修改
阅读量719 收藏 1
点赞数
分类专栏： gobject 文章标签： javascript c++ html
于 2023-04-21 20:46:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51470638/article/details/130296594
版权

参考资料：https://github.com/ToshioCP/Gobject-tutorial/blob/main/gfm/sec6.md

抽象类型没有任何实例。

G_DECLARE_DERIVABLE_TYPE宏用来声明抽象类。这类似于G_DECLARE_FINAL_TYPE宏。

比如面的例子，MNuber是抽象类，G_DECLARE_DERIVABLE_TYPE扩展为：

  1. 函数声明m_number_get_type()，你需要定义它。你可以用G_DEFINE_TYPE等宏定义它。
  2. MNumber实例的定义，它的成员仅仅有它的父类。
  3. MNumberClass的声明。你需要在头文件后面定义它。
  4. M_NUMBER (cast to instance) 、M_NUMBER_CLASS (cast to class) 、M_IS_NUMBER (instance check)、M_IS_MUBER_CLASS (class check)、M_NUMBER_GET_CLASS宏。
  5. 提供g_autoptr()

然后，是定义MNumberClass结构退。

下来，是初始化函数指针，它们被称为类方法或虚函数。子类对象需要覆盖它们。

然后是一些公开的函数。

1. 抽象类MNumber

m_number.h：

#ifndef M_NUMBER_H
#define M_NUMBER_H

#include <glib-object.h>

#define M_TYPE_NUMBER   (m_number_get_type())
G_DECLARE_DERIVABLE_TYPE (MNumber, m_number, M, NUMBER, GObject)

struct _MNumberClass {
	GObjectClass base_class;
	MNumber * (*add) (MNumber *self, MNumber *other);
	MNumber * (*sub) (MNumber *self, MNumber *other);
	MNumber * (*mul) (MNumber *self, MNumber *other);
	MNumber * (*div) (MNumber *self, MNumber *other);
	MNumber * (*uminus) (MNumber *self);
	
	char * (*to_str) (MNumber *self);
};

MNumber *
m_number_add (MNumber *self, MNumber *other);

MNumber *
m_number_sub (MNumber *self, MNumber *other);

MNumber *
m_number_mul (MNumber *self, MNumber *other);

MNumber *
m_number_div (MNumber *self, MNumber *other);

MNumber *
m_number_uminus (MNumber *self);

char *
m_number_to_str (MNumber *self);


#endif // M_NUMBER_H

下面的，G_DEFINE_ABSTRACT_TYPE宏，用于定义抽象类型对象。抽象类型不能被实例化。
这个宏扩展为：

  1. m_number_init()函数声明。
  2. m_number_class_init()函数声明。
  3. m_number_get_tyoe()函数定义
  4. m_number_parent_class静态变量的定义，它指向父类。

虚函数指针分配为NULL，需要让后代覆盖。

m_number_init()是实例初始化函数，但是抽象对象不被实例化，所以它什么都不做。但是不能省略这个函数定义。

m_number.c：

#include "m_number.h"

G_DEFINE_ABSTRACT_TYPE (MNumber, m_number, G_TYPE_OBJECT)

static void
m_number_class_init (MNumberClass *klass)
{
	klass->add = NULL;
	klass->sub = NULL;
	klass->mul = NULL;
	klass->div = NULL;
	klass->uminus = NULL;
	klass->to_str = NULL;
}

static void
m_number_init (MNumber *inst)
{ }

MNumber *
m_number_add (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_NUMBER (self), NULL);
	g_return_val_if_fail (M_IS_NUMBER (other), NULL);
	
	MNumberClass *class_ = M_NUMBER_GET_CLASS (self);
	return class_->add ? class_->add (self, other) : NULL;
}

MNumber *
m_number_sub (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_NUMBER (self), NULL);
	g_return_val_if_fail (M_IS_NUMBER (self), NULL);
	
	MNumberClass *class_ = M_NUMBER_GET_CLASS (self);
	return class_->sub ? class_->sub (self, other) : NULL;
}

MNumber *
m_number_mul (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_NUMBER (self), NULL);
	g_return_val_if_fail (M_IS_NUMBER (other), NULL);
	
	MNumberClass *class_ = M_NUMBER_GET_CLASS (self);
	return class_->mul ? class_->mul (self, other) : NULL;
}

MNumber *
m_number_div (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_NUMBER (self), NULL);
	g_return_val_if_fail (M_IS_NUMBER (other), NULL);
	
	MNumberClass *class_ = M_NUMBER_GET_CLASS (self);
	return class_->div ? class_->div (self, other) : NULL;
}

MNumber *
m_number_uminus (MNumber *self)
{
	g_return_val_if_fail (M_IS_NUMBER (self), NULL);
	
	MNumberClass *class_ = M_NUMBER_GET_CLASS (self);
	return class_->uminus ? class_->uminus (self) : NULL;
}

char *
m_number_to_str (MNumber *self)
{
	g_return_val_if_fail (M_IS_NUMBER (self), NULL);
	
	MNumberClass *class_ = M_NUMBER_GET_CLASS (self);
	return class_->to_str ? class_->to_str (self) : NULL;
}

2. 派生类 MInt

m_int.h：

#ifndef M_INT_H
#define M_INT_H

#include <glib-object.h>
#include "m_number.h"

#define M_TYPE_INT  (m_int_get_type())
G_DECLARE_FINAL_TYPE (MInt, m_int, M, INT, MNumber)

MInt *
m_int_new_with_value (int value);

MInt *
m_int_new (void);

#endif // M_INT_H

m_int.c：

#include "m_int.h"
#include "m_double.h"

#define PROP_INT 1
static GParamSpec *int_property = NULL;

struct _MInt {
	MNumber base_class;
	int value;
};

G_DEFINE_TYPE (MInt, m_int, M_TYPE_NUMBER)

static void
m_int_set_property (GObject *object,
                    guint property_id,
                    const GValue *value,
                    GParamSpec *pspec)
{
	MInt *self = M_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
m_int_get_property (GObject *object,
                    guint property_id,
                    GValue *value,
                    GParamSpec *pspec)
{
	MInt *self = M_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
m_int_init (MInt *d)
{ }

#define m_int_binary_op(op)\
    int i;\
    double d;\
    if (M_IS_INT (other)) {\
        g_object_get (M_INT (other), "value", &i, NULL);\
        return M_NUMBER (m_int_new_with_value (M_INT (self)->value op i));\
    } else {\
        g_object_get (M_DOUBLE (other), "value", &d, NULL);\
        return M_NUMBER (m_int_new_with_value (M_INT (self)->value op (int)d));\
    }

static MNumber *
m_int_add (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_INT (self), NULL);
	m_int_binary_op (+)
}

static MNumber *
m_int_sub (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_INT (self), NULL);
	m_int_binary_op (-)
}

static MNumber *
m_int_mul (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_INT (self), NULL);
	m_int_binary_op (*)
}

static MNumber *
m_int_div (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_INT (self), NULL);
	m_int_binary_op ( /)
}

static MNumber *
m_int_uminus (MNumber *self)
{
	g_return_val_if_fail (M_IS_INT (self), NULL);
	
	return M_NUMBER (m_int_new_with_value (-M_INT (self)->value));
}

static char *
m_int_to_str (MNumber *self)
{
	g_return_val_if_fail (M_IS_INT (self), NULL);
	int i;
	
	g_object_get (M_INT (self), "value", &i, NULL);
	return g_strdup_printf ("%d", i);
}

static void
m_int_class_init (MIntClass *class_)
{
	MNumberClass *mnumber_class = M_NUMBER_CLASS (class_);
	GObjectClass *gobject_class = G_OBJECT_CLASS (class_);
	
	mnumber_class->add = m_int_add;
	mnumber_class->sub = m_int_sub;
	mnumber_class->mul = m_int_mul;
	mnumber_class->div = m_int_div;
	mnumber_class->uminus = m_int_uminus;
	mnumber_class->to_str = m_int_to_str;
	
	gobject_class->set_property = m_int_set_property;
	gobject_class->get_property = m_int_get_property;
	int_property = g_param_spec_int (
	                   "value", "val", "Integer value",
	                   G_MININT, G_MAXINT, 0, G_PARAM_READWRITE
	               );
	g_object_class_install_property (gobject_class, PROP_INT, int_property);
}

MInt *
m_int_new_with_value (int value)
{
	return g_object_new (M_TYPE_INT, "value", value, NULL);
}

MInt *
m_int_new (void)
{
	return g_object_new (M_TYPE_INT, NULL);
}

3. 派生类MDouble

m_double.h：

#ifndef M_DOUBLE_H
#define M_DOUBLE_H

#include <glib-object.h>
#include "m_number.h"

#define M_TYPE_DOUBLE   (m_double_get_type())
G_DECLARE_FINAL_TYPE (MDouble, m_double, M, DOUBLE, MNumber)

MDouble *
m_double_new_with_value (double value);

MDouble *
m_double_new (void);


#endif // M_DOUBLE_H

m_double.c：

#include "m_double.h"
#include "m_int.h"

#define PROP_DOUBLE 1
static GParamSpec *double_property = NULL;

struct _MDouble {
	MDouble base_class;
	double value;
};

G_DEFINE_TYPE (MDouble, m_double, M_TYPE_NUMBER)

static void
m_double_set_property (GObject *object,
                       guint property_id,
                       const GValue *value,
                       GParamSpec *pspec)
{
	MDouble *self = M_DOUBLE (object);
	if (property_id == PROP_DOUBLE)
		self->value = g_value_get_double (value);
	else
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
m_double_get_property (GObject *object,
                       guint property_id,
                       GValue *value,
                       GParamSpec *pspec)
{
	MDouble *self = M_DOUBLE (object);
	if (property_id == PROP_DOUBLE)
		g_value_set_double (value, self->value);
	else
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
m__double_init (MDouble *d)
{ }

#define m_double_binary_op(op)\
    int i;\
    double d;\
    if (M_IS_INT (other)) {\
        g_object_get (M_INT (other), "value", &i, NULL);\
        return M_NUMBER (m_double_new_with_value (M_DOUBLE (self)->value op (double) i));\
    } else {\
        g_object_get (M_DOUBLE (other), "value", &d, NULL);\
        return M_NUMBER (m_double_new_with_value (M_DOUBLE (self)->value op d));\
    }

static MNumber *
m_double_add (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_DOUBLE (self), NULL);
	
	m_double_binary_op (+)
}

static MNumber *
m_double_sub (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_DOUBLE (self), NULL);
	
	m_double_binary_op (-)
}

static MNumber *
m_double_mul (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_DOUBLE (self), NULL);
	
	m_double_binary_op (*)
}

static MNumber *
m_double_div (MNumber *self, MNumber *other)
{
	g_return_val_if_fail (M_IS_DOUBLE (self), NULL);
	
	m_double_binary_op ( /)
}

static MNumber *
m_double_uminus (MNumber *self)
{
	g_return_val_if_fail (M_IS_DOUBLE (self), NULL);
	
	return M_NUMBER (m_double_new_with_value (- M_DOUBLE (self)->value));
}

static MNumber *
m_doube_to_str (MNumber *self)
{
	g_return_val_if_fail (M_IS_DOUBLE (self), NULL);
	double d;
	
	g_object_get (M_DOUBLE (self), 'value', &d, NULL);
	return g_strdup_printf ("%lf", d);
	
}
static void
m_double_class_init (MDoubleClass *class_)
{
	MNumberClass *mnumber_class = M_NUMBER_CLASS (class_);
	GObjectClass *gobject_class = G_OBJECT_CLASS (class_);
	
	mnumber_class->add = m_double_add;
	mnumber_class->sub = m_double_sub;
	mnumber_class->mul = m_double_mul;
	mnumber_class->div = m_double_div;
	mnumber_class->uminus = m_double_uminus;
	mnumber_class->to_str = m_doube_to_str;
	
	gobject_class->set_property = m_double_set_property;
	gobject_class->get_property = m_double_get_property;
	
	double_property = g_param_spec_double (
	                      "value", "val", "Double value",
	                      -G_MAXDOUBLE, G_MAXDOUBLE, 0, G_PARAM_READWRITE
	                  );
	g_object_class_install_property (gobject_class, PROP_DOUBLE, double_property);
}

MDouble *
m_double_new_with_value (double value)
{
	return g_object_new (M_TYPE_DOUBLE, "value", value, NULL);
}

MDouble *
m_double_new (void)
{
	return g_object_new (M_TYPE_DOUBLE, NULL);
}
barbyQAQ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java抽象类及其派生类_深入解析Java编程中的抽象类
weixin_36394468的博客
02-28 1337
深入解析Java编程中的抽象类发布于 2020-4-10|复制链接摘记: Java程序用抽象类(abstract class)来实现自然界的抽象概念。抽象类的作用在于将许多有关的类组织在一起，提供一个公共的类，即抽象类，而那些被它组织在一起的具体的类将作为它的子类由它派生出来。抽象类刻画了公有行为的特征，并通过继承机制传送给它的派生类。在抽象类中定义的方法称为抽象方法，这些方法只有方法头的声明，而...
C++纯虚函数和派生类用法（抽象基类ABC）
净无邪博客
07-02 4255
C++中，如果希望有一个公共基类只声明一个函数接口，在该公共基类不进行定义，而是在派生类才重新定义；重新定义时，不同的派生类重新定义不同的功能，则这种情况下，最好使用C++的纯虚函数和派生类。（最后面有源代码下载） 1.1纯虚函数的特点和作用 a1 在基类声明一批公共的函数接口（在函数声明的分号前赋值=0），不进行定义，而在不同的派生类才重新进行定义；（当然，如果需要，也可以在公共基类中进行定...
java抽象类及其派生类_java抽象类
weixin_29341975的博客
02-28 985
本文指标：1. 最基本的运用：掌握java类最简单，最核心的写法2. 理论知识：语法角度，设计角度3. 几种典型应用最简单也是最核心的抽象类示例：学习应该是一个循序渐进的过程，学java抽象类也好,学数据结构也好，或者其它，深入学习以后会发现知识点很多，如果学习的节奏加快，会感觉有一堆的东西在意念中，而这个时候最需要告诉自己起码最简单的一块已经毫无疑问的掌握着，而最简单的东西往往也最常用。以下的j...
3.抽象类（shape）
W2001r的博客
05-27 5823
3 抽象类 定义一个抽象类shape，包括公有的计算面积area方法，计算体积volume方法，输出基本信息方法printinfo（三个方法均为抽象方法）。从shape派生point类，增加私有数据成员x,y坐标，以及构造方法。从point派生circle类，增加私有数据成员半径r，以及构造方法。从circle派生cylinder类，增加私有数据成员高度h，以及构造方法。在main方法中，定义shape类的对象，引用派生类的对象，输出三类对象的基本信息，面积，体积。 public class Test {
c++抽象基类和派生类
xujianjun229的博客
08-01 1465
#ifndefSTUDENT_H #defineSTUDENT_H //抽象基类，不能用来定义对象或者说抽象类不能实例化，但是可以定义指向抽象类的数据的指针变量,当派生类中无纯虚函数，才成为具体类，就可以用这种指针指向派生类对象，然后通过指针调用虚函数，实现多态操作 //最后注意变量命名规范 #include<iostream> usingnamespacestd; classStudent { public: Student(int...
计算机程序设计c++ 12-3：抽象类
uncle_ll的博客
12-17 1181
抽象类 类是对象的集合，类是从相似对象中抽取共性而得到的抽象数据类型 将不用来声明对象(实例化)的类称为抽象类，只供继承使用 纯虚函数的定义如下: virtual 返回类型 函数名（参数表）= 0 具体实现只能在派生类中完成 抽象类又可以定义成: 至少包含一个纯虚函数的类 抽象类的使用要求 抽象类不能实例化，即不声明对象 抽象类只作为基类被继承 可以定义抽象类的指针或引用 抽象类设计举例 平面上的几何图形可以抽象定义为类，如矩形类、圆类、三角形类等 将所有几何图形再加以抽象，定义为
JAVA抽象类
weixin_44209785的博客
09-15 860
如何定义抽象类 关键字：abstract 格式为：[权限修饰符] abstract class 类名 如：在这里插入代码片 为什么有抽象类 定义类时，通常要定义方法来描述该类的行为特征，但有时这些方法的实现方式无法确定（在不同子类中实现的方法不一样，这是多态的一种体现）；Java允许在定义方法时不写方法体，无方法体的方法称为抽象方法，必须用abstract修饰 ...
接口与抽象类的区别
热门推荐
DavidLiu的博客
12-01 3万+
a、抽象类不能被实例化只能被继承； b、包含抽象方法的一定是抽象类，但是抽象类不一定含有抽象方法； c、抽象类中的抽象方法的修饰符只能为public或者protected，默认为public； d、一个子类继承一个抽象类，则子类必须实现父类抽象方法，否则子类也必须定义为抽象类； e、抽象类可以包含属性、方法、构造方法，但是构造方法不能用于实例化，主要用途是被子类调用。 接口：Java中接口使用interface关键字修饰，特点为: a、接口可以包含变量、方法；变量被隐士指定为public st.
C++ 抽象类
Chroniccandy的博客
10-01 1万+
抽象类(接口) 接口描述了类的行为和功能,而无需完成类的特定实现 C++接口时通过抽象类实现的,设计抽象类的目的,是为了给其他类提供一个可以继承的适当的基类。抽象类本类不能被用于实例化对象,只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。 因此,如果一个抽象类的派生类需要被实例化(建立对象),则必须对每个继承来的纯虚函数进行函数体实现。如果没有在派生类中重写所有纯虚函数,就尝试实例化派生类的对象,也会导致编译错误这是因为 如果派生类没有实现父类的纯虚函数，则派生类变为抽象类 抽象类与纯虚
定义抽象类Person、派生类Student和类Teacher
m0_53662821的博客
05-30 4651
定义抽象类Person、派生类Student和类Teacher
C++学习篇?纯虚函数和抽象类
12-22
在C++编程语言中，纯虚函数和抽象类是面向对象设计的重要概念，它们主要用于创建类的继承层次结构。理解这两个概念对于开发复杂的、可扩展的软件系统至关重要。 纯虚函数，正如标题所言，是一种特殊的虚函数。虚...
08-Class类(派生类和抽象类).ts
03-06
08-Class类(派生类和抽象类)
vehicle类_抽象类Vehicle_vehicle类_
09-29
在这个场景中，我们将探讨如何使用C++来设计一个抽象类`Vehicle`，并从这个抽象类派生出具体的类`Car`和`Truck`。抽象类通常用于定义一个基类，它包含了一些共同的方法和属性，但不提供具体实现，而是由其子类去完成...
java：接口和抽象类练习
12-21
在Java编程语言中，抽象类和接口是两种重要的机制，它们用于实现面向对象设计的多态性和抽象性。下面将详细解释这两个概念及其差异。 **抽象类** 是一种特殊的类，它不能被实例化，其主要目的是为了被其他类继承。...
C#抽象类和接口的区别分析
01-01
很多C#的初学者在编程时都容易把抽象类和接口搞混,本文就为大家从概念上讲解抽象类和接口的区别： 一、抽象类： 含有abstract修饰符的class即为抽象类，抽象类是特殊的类，只是不能被实例化，可以创建一个变量，其...
Arco Design for Vue 3 - 快速上手指南与实战技巧
qq_42072014的博客
08-11 493
如果你在使用 TypeScript 时遇到了类型定义问题，确保你安装了正确的类型包，并且版本与 Arco Design 的版本相匹配。Arco Design for Vue 3 是一个非常强大的 UI 框架，它不仅提供了丰富的组件和功能，还有完善的文档和支持。通过本文，你已经掌握了如何快速上手 Arco Design，并学会了一些实用的技巧来提升你的开发效率。希望这些经验能帮助你在 Vue 3 的开发过程中更进一步！
Electron学习与总结
song854601134的博客
08-12 186
组成，‌其中Chromium负责渲染和显示Web页面，‌而Node.js则提供了主进程的功能，‌包括管理应用程序的生命周期、‌创建和控制浏览器窗口以及与操作系统交互。，‌Electron使得开发者能够保持JavaScript代码库的一致性，‌从而轻松地创建跨平台的应用程序，‌而无需具备本地开发经验。Electron的核心是由。
牛客JS题（三十四）监听对象
不起眼小菜菜的博客
08-10 417
注释很详细，直接上代码……
【Markdown】Markdown 中的语言简称
最新发布
EleganceJiaBao的博客
08-12 660
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
c++抽象类的派生类时抽象类吗
06-04
在C++中，抽象类是指至少包含一个纯虚函数的类...因此，在C++中，如果派生类没有实现所有继承自抽象类的纯虚函数，那么这个派生类也将变成抽象类。需要注意的是，抽象类不能够被直接实例化，只能用来作为其他类的基类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

barbyQAQ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值