CN112988279B - Object processing method and device, electronic equipment and storage medium - Google Patents

Abstract

The invention discloses an object processing method, an object processing device, electronic equipment and a storage medium, which are used for solving the technical problem that in the prior art, an object created through a module is released through other modules in the actual programming process. The method comprises the following steps: when an object creation instruction aiming at a preset registration realization class is received, acquiring a dynamic expansion module corresponding to the registration realization class from a preset expandable object creation system; creating an object of a registration realization class through a dynamic expansion module; when a release instruction for an object is received, a dynamic expansion module corresponding to the object is acquired in an expandable object creation system; the object is released by the dynamic expansion module.

Description

Object processing method, device, electronic device and storage medium

Technical Field

The present invention relates to the technical field of application development, and in particular to an object processing method, device, electronic device and storage medium.

Background Art

At present, most enterprise-level application systems adopt three-tier or multi-tier application models. Most enterprise-level application systems choose object-oriented programming technology. The so-called "object" is a collection of one or a group of data and the methods and processes for processing these data. There are two basic ways to generate objects. One is to generate new objects based on prototype objects, and the other is to generate new objects based on classes.

In practical applications, the existing technology can use the new and delete operators to create and release class objects. In order to avoid memory leaks, these two operators usually need to be used in pairs.

In the actual programming process, it is often the case that class objects are created and released in different modules (dynamic link libraries), which can easily lead to errors.

Summary of the invention

The present invention provides an object processing method, device, electronic device and storage medium, which are used to solve the technical problem that objects created by modules in the prior art are released by other modules during the actual programming process.

The present invention provides an object processing method, comprising:

When receiving an object creation instruction for a preset registration implementation class, obtaining a dynamic extension module corresponding to the registration implementation class in a preset extensible object creation system;

Creating an object of the registration implementation class through the dynamic extension module;

When a release instruction for the object is received, acquiring the dynamic extension module corresponding to the object in the extensible object creation system;

The object is released by the dynamic extension module.

Optionally, when receiving an object creation instruction for a preset registration implementation class, before the step of acquiring a dynamic extension module corresponding to the registration implementation class in a preset extensible object creation system, the method further includes:

Create an interface;

Declaring the interface to a preset extensible object creation system;

Writing an implementation class of the declared interface in the dynamic extension module;

The implementation class is registered with the extensible object creation system to obtain a registered implementation class.

Optionally, the step of creating an object of the registration implementation class through the dynamic extension module includes:

Obtaining an identifier of the registration implementation class through the dynamic extension module;

Obtaining a constructor of the registration implementation class based on the identifier;

The constructor is used to create an object of the registration implementation class.

Optionally, the step of releasing the object through the dynamic extension module includes:

Obtaining a destructor of the registration implementation class based on the identifier through the dynamic extension module;

The object is released using the destructor.

The present invention also provides an object processing device, comprising:

A first dynamic extension module acquisition module is used to, when receiving an object creation instruction for a preset registration implementation class, acquire a dynamic extension module corresponding to the registration implementation class in a preset extensible object creation system;

An object creation module, used to create an object of the registration implementation class through the dynamic extension module;

A second dynamic extension module acquisition module is used to acquire the dynamic extension module corresponding to the object in the extensible object creation system when receiving a release instruction for the object;

The object releasing module is used to release the object through the dynamic extension module.

Optionally, it also includes:

Interface creation module, used to create interfaces;

An interface declaration module, used for declaring the interface to a preset extensible object creation system;

An implementation class writing module, used for writing the implementation class of the declared interface in the dynamic extension module;

The implementation class registration module is used to register the implementation class with the extensible object creation system to obtain a registered implementation class.

Optionally, the object creation module includes:

An identifier acquisition submodule, used to acquire the identifier of the registration implementation class through the dynamic extension module;

A constructor acquisition submodule, used for acquiring the constructor of the registration implementation class based on the identifier;

The object creation submodule is used to adopt the constructor to create an object of the registration implementation class.

Optionally, the object releasing module includes:

A destructor acquisition submodule, used to acquire the destructor of the registered implementation class based on the identifier through the dynamic extension module;

The object release submodule is used to release the object using the destructor.

The present invention also provides an electronic device, the device comprising a processor and a memory:

The memory is used to store program code and transmit the program code to the processor;

The processor is used to execute any one of the above object processing methods according to the instructions in the program code.

The present invention also provides a computer-readable storage medium, wherein the computer-readable storage medium is used to store program codes, and the program codes are used to execute the object processing method as described in any one of the above items.

It can be seen from the above technical scheme that the present invention has the following advantages: when receiving an object creation instruction for a preset registration implementation class, the present invention obtains a dynamic extension module corresponding to the registration implementation class in a preset extensible object creation system; creates an object of the registration implementation class through the dynamic extension module; when receiving a release instruction for the object, obtains a dynamic extension module corresponding to the object in the extensible object creation system; and releases the object through the dynamic extension module. This solves the technical problem that objects created by modules in the prior art are released through other modules in the actual programming process.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

FIG1 is a flowchart of a method for processing an object provided by an embodiment of the present invention;

FIG2 is a flowchart of a method for processing an object according to another embodiment of the present invention;

FIG3 is a schematic diagram of a process of an object processing method provided by an embodiment of the present invention;

FIG. 4 is a structural block diagram of an object processing device provided by an embodiment of the present invention.

DETAILED DESCRIPTION

The embodiments of the present invention provide an object processing method, device, electronic device and storage medium, which are used to solve the technical problem that objects created by modules in the prior art are released by other modules during the actual programming process.

In order to make the purpose, features and advantages of the present invention more obvious and easy to understand, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the embodiments described below are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

Please refer to FIG. 1 , which is a flow chart of the steps of an object processing method provided by an embodiment of the present invention.

The object processing method provided by the present invention may specifically include the following steps:

Step 101, when an object creation instruction for a preset registration implementation class is received, a dynamic extension module corresponding to the registration implementation class is obtained in a preset extensible object creation system;

In the embodiment of the present invention, the dynamic extension module may be a dynamic link library or a component library.

Dynamic Link Library (DLL) is a way to implement the concept of shared function libraries in Windows operating systems. These functions have the extension ".dll", ".ocx" (libraries containing ActiveX controls), or ".drv" (old-style system drivers). Dynamic linking provides a way for a process to call functions that are not part of its executable code. The executable code of a function is located in a DLL file, which contains one or more functions that have been translated, linked, and stored separately from the processes that use them. DLL also helps to share data and resources. Multiple applications can access the contents of a single copy of a DLL in memory at the same time. Using dynamic link libraries, updates can be applied to individual modules more easily without affecting other parts of the program. DLL provides the role of shared libraries such as modularity, which allows only the code and data in a DLL shared by several applications to be changed without changing the application itself. Another benefit of modularity is the use of common interfaces for plug-ins. A single interface allows old modules to be seamlessly integrated with previous application runtimes just like new modules, without making any changes to the application itself.

In the embodiment of the present invention, an extensible object creation system can be pre-built, in which a dynamic link library is deployed, wherein the dynamic link library can be one or more.

In the embodiment of the present invention, the extensible object creation system can be plug-in and component-based programming. At the same time, it can provide methods such as interface declaration, implementation class registration, object creation and release, dynamic extension module loading and unloading, and obtaining the registered names of all registered implementation classes of a specified interface.

In actual applications, when an object creation instruction for a preset registration implementation class is received, a dynamic extension module corresponding to the registration implementation class can be obtained in a preset extensible object creation system to perform object creation.

Step 102, creating an object of the registration implementation class through the dynamic extension module;

After obtaining the dynamic extension module for object creation, you can use the object creation method provided by the extensible object creation system to create the object of the registration implementation class, and then complete the call of related methods through the interface corresponding to the registration implementation class. Among them, the registration implementation class and its interface can be in the same dynamic extension module or not.

Step 103, when a release instruction for an object is received, a dynamic extension module corresponding to the object is obtained in the extensible object creation system;

Step 104: Release the object through the dynamic extension module.

In the embodiment of the present invention, after the object creation is completed, when a release instruction for the object is received, the dynamic extension module corresponding to the registered implementation class can be obtained in the extensible object creation system to release the object through the dynamic extension module.

The present invention obtains the dynamic extension module corresponding to the registered implementation class in the extensible object creation system, so as to create an object through the dynamic extension module. At the same time, according to the corresponding relationship between the registered implementation class and the dynamic extension module, when the object needs to be released, the same dynamic extension module can be obtained to perform the object release operation.

Please refer to Figure 2, which is a flowchart of a method for processing an object provided by another embodiment of the present invention. The method may specifically include the following steps:

Step 201, create an interface;

An interface is a collection of definitions of abstract methods and constant values. In essence, an interface is a special abstract class that only contains constant and method definitions, but no variable and method implementations. An interface generally defines how to use it, including how external programs call it, and how internal programs call each other.

In the embodiment of the present invention, the user can write the required interface in the general basic module/bottom layer module, such as the ICommand class interface. Among them, the interface created in the embodiment of the present invention needs to meet the following requirements: all methods must be pure virtual methods and do not contain any member variables, and the interface must be in a .h file.

A pure virtual method is also called an abstract function. Generally speaking, it only has a function name, parameters, and return value type, and does not require a function body. This means that it has no function implementation and needs to be implemented by the derived class.

In C++, pure virtual methods usually use = 0 after the function signature as a sign of this type of function. In languages such as Java and C#, abstract is directly used as a keyword to modify the function signature, indicating that this is a pure virtual method.

Step 202, declaring an interface to a preset extensible object creation system;

In the embodiment of the present invention, after the interface creation is completed, the interface can be declared to the extensible object creation system.

In one example, the declaration method provided by the extensible object creation system, such as EXTENSIBLE_FACTORY_DECLARE, can be used for declaration. A single interface only needs to be declared once. At the same time, the definition is performed in any .cpp file of the module where the interface is located, using the declaration method EXTENSIBLE_FACTORY_DEFINE provided by the extensible object creation system, which includes the .h file where the interface is located.

Step 203, writing the implementation class of the declared interface in the dynamic extension module;

A class is a reflection of an entity in the real world or the mental world in a computer. It encapsulates data and operations on the data. An implementation class is used to implement the functions of an interface.

In the embodiment of the present invention, the implementation class of the interface can be written in the dynamic extension module, and all pure virtual methods inherited from the interface can be implemented.

Among them, the technical requirements for the implementation class are as follows: its constructor must meet the requirements of the extensible object creation system, the type of the first parameter must be const char*, the type of the second parameter must be const void*, and it can only contain two parameters.

Step 204, registering the implementation class with the extensible object creation system to obtain the registered implementation class;

After the implementation class is written, the implementation class can be registered in the source file (CPP) of the implementation class of the dynamic extension module of the extensible creation system.

Specifically, the registration may be performed through the registration method EXTENSIBLE_FACTORY_REGISTER provided by the extensible object creation system, thereby obtaining a registration implementation class.

It should be noted that a specific implementation class can only be registered with the interface it inherits; the same implementation class can register multiple names and only needs to be registered once; the same interface can be registered by multiple implementation classes.

Step 205, when receiving an object creation instruction for a preset registration implementation class, obtaining a dynamic extension module corresponding to the registration implementation class in a preset extensible object creation system;

In the embodiment of the present invention, after receiving an object creation instruction for a preset registration implementation class, the dynamic extension module can be loaded through a method provided by the extensible object creation system.

In an example, the method for loading the dynamic extension module may be extensible_factory_load_dlls.

Step 206, creating an object of the registration implementation class through the dynamic extension module;

An object is an abstraction of objective things. It is a variable with a class type. Class and object are the most basic concepts in object-oriented programming technology. A class is an abstraction of an object, and an object is a specific instance of a class. A class is a template that describes the behavior and state of a class of objects, while an object is an example of a class with state and behavior. For example, a dog is a class, and a dog is an object. Its states include: color, name, and breed; its behaviors include: wagging its tail, barking, eating, etc.

In the embodiment of the present invention, after the loading operation of the dynamic extension module is completed, an object of the registration implementation class can be created through the dynamic extension module.

Specifically, the object is created through the method extensible_factory_get_xxx provided by the extensible object creation system, where xxx is the name of the interface class.

In one example, step 206 may include the following sub-steps:

S61, obtaining an identifier of a registration implementation class through a dynamic extension module;

S62, obtaining a constructor of the registration implementation class based on the identifier;

S63, using the constructor, to create an object of the registration implementation class.

In the specific implementation, when creating an object, you can use the specified identifier to obtain the constructor of the implementation class through the global Map, and call the constructor to create an object of the interface class.

The constructor is mainly used to initialize the object when creating it, that is, to assign initial values to the object member variables. It is always used together with the new operator in the statement to create the object. A class can have multiple constructors, which can be distinguished by the number of parameters or the type of parameters.

Step 207, when a release instruction for the object is received, a dynamic extension module corresponding to the object is obtained in the extensible object creation system;

In the embodiment of the present invention, when a release instruction for an object is received, the object can be released by creating a dynamic extension module of the object.

Step 208: Release the object through the dynamic extension module.

In the embodiment of the present invention, the object can be released through the object release method extensible_factory_release_xxx provided by the extensible object creation system, where xxx is the name of the interface class.

In one example, step 208 may include the following sub-steps:

S81, obtaining the destructor of the registered implementation class based on the identifier through the dynamic extension module;

S82, use the destructor to release the object.

In the specific implementation, when releasing the object, the destructor of the implementation class can be obtained through the global Map through the specified identifier, and the destructor is called to release the object of the interface class.

Among them, the destructor is the opposite of the constructor. When the object ends its life cycle, such as when the function where the object is located has been called, the destructor can be executed to release the object.

It should be noted that the constructors and destructors of all implementation classes must be in a fixed format, with unified parameter types, parameter order, and number of parameters.

The present invention obtains the dynamic extension module corresponding to the registered implementation class in the extensible object creation system, so as to create an object through the dynamic extension module. At the same time, according to the corresponding relationship between the registered implementation class and the dynamic extension module, when the object needs to be released, the same dynamic extension module can be obtained to perform the object release operation.

For ease of understanding, the embodiments of the present invention are described below by using specific examples:

Please refer to FIG. 3 , which is a schematic diagram of a process of an object processing method provided by an embodiment of the present invention.

As shown in Figure 3, the extensible object creation system provides operations such as interface declaration, implementation class registration, object creation and release, etc. In addition, it also provides methods such as loading and unloading dynamic extension modules and obtaining the registered names of all registered implementation classes of a specified interface. Its implementation principle is as follows:

1. EXTENSIBLE_FACTORY_DECLARE is responsible for declaring the factory method of the corresponding interface class. The declared method is extensible_get_xxx, etc., where xxx is the name of the interface class.

2. EXTENSIBLE_FACTORY_DEFINE is responsible for implementing the declared factory method. The implementation principle is: when creating an object, the constructor of the implementation class is obtained through the global Map through the specified identifier, and the constructor is called to create an object of the interface class. When releasing the object, the destructor of the implementation class is obtained through the global Map through the specified identifier, and the destructor is called to release the object of the interface class. Therefore, the constructors and destructors of all implementation classes must be in a fixed format, with unified parameter types, parameter order, and number of parameters.

3. EXTENSIBLE_FACTORY_REGISTER is responsible for registering the relevant information of the implementation class (class name, constructor, destructor, etc.) into the global Map.

4. The application creates and releases objects through the extensible_factory_get_xxx and extensible_factory_release_xxx methods of the extensible object creation system.

The following are examples of its use:

//Common module needs to define DLL_API_SPEC = __declspec(dllexport)

//Common module's Command.h

//ICommand is an interface, all methods are pure virtual methods, and do not contain member variables

class ICommand

{

virtual const char*getCommandName()=0;

virtual void setCommandName(const char*cmdName)=0;

};

#ifndef DLL_API_SPEC

#define DLL_API_SPEC__declspec(dllimport)

#endif

EXTENSIBLE_FACTORY_DECLARE(ICommand,DLL_API_SPEC);

//Common module Command.cpp

#include "Command.h"

EXTENSIBLE_FACTORY_DEFINE(ICommand);

//CommandImp.cpp of the component module CommandSpectial

class Command1

{

//The constructor must be in the following form, with fixed parameter types and numbers

Command1(const char*csaParam,const void*binParam)

{

}

const char*getCommandName()

{

return 0;

}

void setCommandName(const char*cmdName)

{

}

};

EXTENSIBLE_FACTORY_REGISTER(ICommand,Command1,"cmd1","Command1");

class Command2

{

//The constructor must be in the following form, with fixed parameter types and numbers

Command2(const char*csaParam,const void*binParam)

{

}

const char*getCommandName()

{

return 0;

}

void setCommandName(const char*cmdName)

{

}

};

EXTENSIBLE_FACTORY_REGISTER(ICommand,Command2,"cmd2","Command2");

//Use of ICommand interface

#include "Command.h"

//First load the component where the command is located

extensible_factory_load_dlls("CommandSpectial");

//Create the corresponding class object through the extensible factory

ICommand*command1=extensible_factory_get_ICommand("cmd1",0);

//Release the corresponding class object through the extensible factory

extensible_factory_release_ICommand(command1);

ICommand*command2=extensible_factory_get_ICommand("cmd2",0);

extensible_factory_release_ICommand(command2);

Please refer to FIG. 4 , which is a structural block diagram of an object processing device provided by an embodiment of the present invention.

An embodiment of the present invention provides an object processing device, comprising:

A first dynamic extension module acquisition module 401 is used to acquire a dynamic extension module corresponding to a registration implementation class in a preset extensible object creation system when receiving an object creation instruction for a preset registration implementation class;

The object creation module 402 is used to create an object of the registration implementation class through the dynamic extension module;

A second dynamic extension module acquisition module 403 is used to acquire the dynamic extension module corresponding to the object in the extensible object creation system when receiving a release instruction for the object;

The object release module 404 is used to release the object through the dynamic extension module.

In an embodiment of the present invention, it also includes:

Interface creation module, used to create interfaces;

An interface declaration module, used to declare an interface to a preset extensible object creation system;

The implementation class writing module is used to write the implementation class of the declared interface in the dynamic extension module;

The implementation class registration module is used to register the implementation class with the extensible object creation system to obtain the registered implementation class.

In the embodiment of the present invention, the object creation module 402 includes:

The identifier acquisition submodule is used to obtain the identifier of the registered implementation class through the dynamic extension module;

The constructor acquisition submodule is used to obtain the constructor of the registered implementation class based on the identifier;

The object creation submodule is used to create objects of the registered implementation class using the constructor.

In the embodiment of the present invention, the object release module 404 includes:

The destructor acquisition submodule is used to obtain the destructor of the registered implementation class based on the identifier through the dynamic extension module;

The object release submodule is used to release objects using destructors.

An embodiment of the present invention further provides an electronic device, the device comprising a processor and a memory:

The memory is used to store program codes and transmit the program codes to the processor;

The processor is used to execute the object processing method of any embodiment of the present invention according to the instructions in the program code.

An embodiment of the present invention further provides a computer-readable storage medium, which is used to store program codes, and the program codes are used to execute the object processing method of any embodiment of the present invention.

Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

The various embodiments in this specification are described in a progressive manner, and each embodiment focuses on the differences from other embodiments. The same or similar parts between the various embodiments can be referenced to each other.

Those skilled in the art will appreciate that the embodiments of the embodiments of the present invention may be provided as methods, devices, or computer program products. Therefore, the embodiments of the present invention may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, the embodiments of the present invention may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program codes.

The embodiments of the present invention are described with reference to the flowcharts and/or block diagrams of the methods, terminal devices (systems), and computer program products according to the embodiments of the present invention. It should be understood that each process and/or box in the flowchart and/or block diagram, as well as the combination of the processes and/or boxes in the flowchart and/or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing terminal device to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing terminal device generate a device for implementing the functions specified in one process or multiple processes in the flowchart and/or one box or multiple boxes in the block diagram.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing terminal device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce a manufactured product including an instruction device that implements the functions specified in one or more processes in the flowchart and/or one or more boxes in the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing terminal device so that a series of operating steps are executed on the computer or other programmable terminal device to produce computer-implemented processing, so that the instructions executed on the computer or other programmable terminal device provide steps for implementing the functions specified in one or more processes in the flowchart and/or one or more boxes in the block diagram.

Although the preferred embodiments of the present invention have been described, those skilled in the art may make additional changes and modifications to these embodiments once they have learned the basic creative concept. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments and all changes and modifications that fall within the scope of the embodiments of the present invention.

Finally, it should be noted that, in this article, relational terms such as first and second, etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "include", "comprise" or any other variants thereof are intended to cover non-exclusive inclusion, so that a process, method, article or terminal device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or terminal device. In the absence of further restrictions, the elements defined by the sentence "comprise a ..." do not exclude the existence of other identical elements in the process, method, article or terminal device including the elements.

As described above, the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that the technical solutions described in the aforementioned embodiments may still be modified, or some of the technical features may be replaced by equivalents. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims (8)

1. An object processing method, comprising: When an object creation instruction for a preset registered implementation class is received, a dynamic extension module corresponding to the registered implementation class is obtained in a preset extensible object creation system; wherein the dynamic extension module is a dynamic link library or a component library, wherein the extensible object creation system can perform plug-in and component programming; and can also provide methods for interface declaration, implementation class registration, object creation and release, dynamic extension module loading and unloading, and obtaining the registered names of all registered implementation classes of a specified interface; Creating an object of the registration implementation class through the dynamic extension module includes: Using a constructor, create an object of the registration implementation class; The constructor must meet the requirements of the extensible object creation system. The type of the first parameter must be const char*, the type of the second parameter must be const void*, and it can only contain these two parameters. After obtaining the dynamic extension module for object creation, the object of the registration implementation class can be created through the object creation method provided by the extensible object creation system, and then the relevant method is called through the interface corresponding to the registration implementation class; wherein the registration implementation class and its interface are in the same dynamic extension module; when a release instruction for the object is received, the dynamic extension module corresponding to the object is obtained in the extensible object creation system; Releasing the object through the dynamic extension module; Wherein, when receiving an object creation instruction for a preset registration implementation class, before the step of acquiring a dynamic extension module corresponding to the registration implementation class in a preset extensible object creation system, the method further includes: Create an interface, where all methods of the interface must be pure virtual methods and do not contain any member variables, and the interface must be in a .h file; Declaring the interface to a preset extensible object creation system; Writing an implementation class of the declared interface in the dynamic extension module, wherein the implementation class can only be registered with the interface it inherits; The implementation class is registered with the extensible object creation system to obtain a registered implementation class. 2. The method according to claim 1, characterized in that the step of creating an object of the registration implementation class through the dynamic extension module comprises: Obtaining an identifier of the registration implementation class through the dynamic extension module; A constructor of the registration implementation class is obtained based on the identifier. 3. The method according to claim 2, characterized in that the step of releasing the object through the dynamic extension module comprises: Obtaining a destructor of the registration implementation class based on the identifier through the dynamic extension module; The object is released using the destructor. 4. An object processing device, comprising: A first dynamic extension module acquisition module is used to, when receiving an object creation instruction for a preset registration implementation class, acquire the dynamic extension module corresponding to the registration implementation class in a preset extensible object creation system; wherein the dynamic extension module is a dynamic link library or a component library, wherein the extensible object creation system can perform plug-in and component programming; and can also provide methods for interface declaration, implementation class registration, object creation and release, dynamic extension module loading and unloading, and acquisition of the registered names of all registered implementation classes of a specified interface; An object creation module, used to create an object of the registration implementation class through the dynamic extension module, including: Using a constructor, create an object of the registration implementation class; The constructor must meet the requirements of the extensible object creation system. The type of the first parameter must be const char*, the type of the second parameter must be const void*, and it can only contain these two parameters. After obtaining the dynamic extension module for object creation, the object creation method provided by the extensible object creation system can be used to create the object of the registration implementation class, and then the corresponding interface of the registration implementation class is used to complete the call of the relevant method; wherein, the registration implementation class and its interface are in the same dynamic extension module; A second dynamic extension module acquisition module is used to acquire the dynamic extension module corresponding to the object in the extensible object creation system when receiving a release instruction for the object; An object release module, used for releasing the object through the dynamic extension module; Among them, it also includes: An interface creation module, used to create an interface, wherein all methods of the interface must be pure virtual methods and do not contain any member variables, and the interface must be in a .h file; An interface declaration module, used for declaring the interface to a preset extensible object creation system; An implementation class writing module, used for writing the implementation class of the declared interface in the dynamic extension module, wherein the implementation class can only be registered with the interface it inherits; The implementation class registration module is used to register the implementation class with the extensible object creation system to obtain a registered implementation class. 5. The device according to claim 4, characterized in that the object creation module comprises: An identifier acquisition submodule, used to acquire the identifier of the registration implementation class through the dynamic extension module; The constructor acquisition submodule is used to acquire the constructor of the registration implementation class based on the identifier. 6. The device according to claim 5, characterized in that the object release module comprises: A destructor acquisition submodule, used to acquire the destructor of the registered implementation class based on the identifier through the dynamic extension module; The object release submodule is used to release the object using the destructor. 7. An electronic device, characterized in that the device comprises a processor and a memory: The memory is used to store program code and transmit the program code to the processor; The processor is used to execute the object processing method according to any one of claims 1 to 3 according to the instructions in the program code. 8. A computer-readable storage medium, characterized in that the computer-readable storage medium is used to store program codes, and the program codes are used to execute the object processing method according to any one of claims 1 to 3.