1. 初始化总结
Invocation time | Function Invoked | Function's parameters | Remark |
---|---|---|---|
First call tog_object_new for target type | target type's base_init function | On the inheritance tree of classes from fundamental type to target type. base_init is invoked once for each class structure. | I have no real idea on how this can be used. If you have a good real-life example of how a class' base_init can be used, please, let me know. |
target type's class_init function | On target type's class structure | Here, you should make sure to initialize or override class methods (that is, assign to each class' method its function pointer) and create the signals and the properties associated to your object. | |
interface' base_init function | On interface' vtable | ||
interface' interface_init function | On interface' vtable | ||
Each call tog_object_new for target type | target type's class constructor method: GObjectClass->constructor | On object's instance | If you need to complete the object initialization after all the construction properties are set, override the constructor method and make sure to chain up to the object's parent class before doing your own initialization. In doubt, do not override the constructor method. |
type's instance_init function | On the inheritance tree of classes from fundamental type to target type. the instance_init provided for each type is invoked once for each instance structure. | Provide an instance_init function to initialize your object before its construction properties are set. This is the preferred way to initialize a GObject instance. This function is equivalent to C++ constructors. |
2. Readers should feel concerned about one little twist in the order in which functions are invoked: while, technically, the class' constructor method is called before the GType's instance_init function (since g_type_create_instance
which calls instance_init is called by g_object_constructor
which is the top-level class constructor method and to which users are expected to chain to), the user's code which runs in a user-provided constructor will always run after GType's instance_init function since the user-provided constructor must (you've been warned) chain up before doing anything useful.
3. gobject 析构
Invocation time | Function Invoked | Function's parameters | Remark |
---|---|---|---|
Last call tog_object_unref for an instance of target type | target type's dispose class function | GObject instance | When dispose ends, the object should not hold any reference to any other member object. The object is also expected to be able to answer client method invocations (with possibly an error code but no memory violation) until finalize is executed. dispose can be executed more than once. dispose should chain up to its parent implementation just before returning to the caller. |
target type's finalize class function | GObject instance | Finalize is expected to complete the destruction process initiated by dispose. It should complete the object's destruction. finalize will be executed only once. finalize should chain up to its parent implementation just before returning to the caller. The reason why the destruction process is split is two different phases is explained in the section called “Reference counts and cycles”. | |
Last call tog_object_unref for the last instance of target type | interface' interface_finalize function | On interface' vtable | Never used in practice. Unlikely you will need it. |
interface' base_finalize function | On interface' vtable | Never used in practice. Unlikely you will need it. | |
target type's class_finalize function | On target type's class structure | Never used in practice. Unlikely you will need it. | |
type's base_finalize function | On the inheritance tree of classes from fundamental type to target type. base_init is invoked once for each class structure. | Never used in practice. Unlikely you will need it. |