Components or libraries provide some functions. Other modules may access these functions through their interface. In some cases, the
interface functions may be simple. The caller constructs input arguments, calls the function, and gets the return value. These type interfaces are easy to define and have no more restrictions. But in other cases,
interface functions may be more complicated. Let’s use an example to explain this in detail.
Suppose that there is a C/C++ component. It provides a function to draw and fill a circle into memory pixel buffer. If the component uses a simple interface, it should take parameters as input arguments, such as line type, color, width, fill color, fill pattern, fill bitmap, etc. We define an
interface object that contains this function in a common object environment. The function may be called by other languages, for example, Java.
In this case, there are some disadvantages. First, the interface function may have many input arguments, and for each call, these arguments should be input although their values do not change. Second, if a new parameter is added, all related functions must be changed. This will increase the burden of software maintenance.
In general, we often define two other objects: pen and brush objects. The
draw function takes
brush objects as input arguments. The
pen object has attributes
width, and the
brush object has attributes
image, etc. We also define an
interface object that contains the
draw function in the common object environment. As a result, there are three objects defined by C/C++ in the environment, which are
brush, and the object containing the
draw function. For other languages using the function, for example Java, it should create instances of the three interface class objects. And the instances can be accessed by C/C++ and Java language based on the support of the environment.
In this case, the function call is more complicated. The caller needs to create instances of objects defined in C/C++. The instances can be accessed by the two languages. They are used as input arguments of the
draw function. Without the support of common object environment, it is difficult to realize it in this way, especially to support the call from applications programmed with multiple different languages.
It is clear that the C/C++ service can be called by any other language. Is it easy and concise? You can compare it with traditional methods using the JNI interface.