Data processing: software development – installation – and managem – Software program development tool – Linking
Reexamination Certificate
1997-09-15
2002-09-03
Maung, Zarni (Department: 2151)
Data processing: software development, installation, and managem
Software program development tool
Linking
C709S241000
Reexamination Certificate
active
06446259
ABSTRACT:
FIELD OF THE INVENTION
The present invention is directed to object oriented computer programming languages and, in particular, to a compiler which implements virtual inheritance in object oriented programs.
BACKGROUND OF THE INVENTION
Object oriented computer programming (OOP) techniques for facilitating the development of complex computer programs are well-known and widely used. As understood by those skilled in the art, these techniques involve the definition, creation, use and destruction of “objects.” These objects are software entities including both data elements and functions which manipulate the data elements. The data and related functions are treated by the software as an entity that can be created, used and deleted as if it were a single item. Together, the data and functions enable objects to model any real world entity in terms of its characteristics, which can be represented by the data elements, and its behavior, which can be represented by its data manipulation functions. In this way, objects can model concrete things, as well as abstract concepts, such as numbers or geometrical designs.
In an OOP programming language, objects are defined by creating “classes,” which are not objects themselves, but act as templates that instruct the compiler how to construct actual objects which are “instances” of the classes. For example, a class may specify the number and type of data variables and the steps involved in the functions which manipulate the data. A corresponding object is actually created by a special function called a “constructor”. The constructor uses the corresponding class definition and additional information, such as arguments specified during object creation, to create an object. Similarly, objects are destroyed by a special function called a “destructor” when the objects are no longer of use.
The principle benefits of OOP techniques arise out of three basic characteristics: encapsulation; polymorphism; and inheritance. Data encapsulation refers to the binding of data and related functions. More specifically, an object can be designed to “hide” (or “encapsulate”), all or a portion of its internal data structure and corresponding internal functions. For instance, during program design, a program developer can define objects in which all or some of the data variables and all or some of the related functions are considered “private” or for use by only the object itself. Other data or functions can be declared “public” or available for use externally of the object. External access to private functions or data can be controlled by defining public functions for an object which can be invoked externally of the object. The public functions form a controlled and consistent interface between the private data and the outside world. Any attempt to write program code which directly accesses the private functions or data causes the compiler to generate an error message during compilation and stop the compilation process.
Polymorphism is a characteristic which allows multiple functions that have the same overall purpose, but that work with different data, to produce consistent results. Inheritance allows program developers to easily reuse preexisting functions and to reduce the need for creating redundant functions from scratch. The principles of inheritance allow a software developer to declare classes (and the objects which are later created from them) as related. Specifically, classes may be designated as derived classes of other base classes. A derived class inherits and has access to functions of its base classes just as if these functions appeared in the derived class. Alternatively, a derived class can override or modify an inherited function merely by defining a new function with the same name. Overriding or modifying does not alter the function in the base class, but merely modifies the use of the function in the derived class. The creation of a new derived class which has some of the functionality (with selective modification) of another class allows software developers to easily customize existing code to meet their particular needs.
One widely used and well known OOP language is C++. The C++ language is classified as a hybrid OOP language, as opposed to a pure or orthodox OOP language. Because the C++ language was designed as an improvement to and as an extension of C, it is full of the traditional features of ANSI C. C++ source code is usually compiled before being executed. Therefore, the C++ programming process entails a development cycle of editing, compiling, linking, and running. Although the iteration through the cycle is a slow process, the produced code is very fast and efficient. The C++ language provides an excellent balance between power of expression, run time speed, and memory requirements. C++ compilers are commercially available from several vendors.
Inheritance may provide the most power to the class concept in OOP. Inheritance allows classes to be continually built and extended with essentially no limit. C++ is different from some OOP languages because it allows multiple inheritance.
To illustrate the concept of virtual inheritance, reference will be made to the class inheritance trees in
FIGS. 1A and 1B
. In
FIG. 1A
, class D directly descends from both base classes B and C and indirectly descends from class A. In this example, class D might appear to a compiler to have two distinct A classes appearing as base classes. Having multiple copies of the same base class in an inheritance tree in the compiled program is confusing and wastes storage space. To solve this problem, a base class may be declared to be virtual so that the compiler is directed to share a single copy of a given base class object in the derived class objects. A class inheritance tree using class A as a virtual base class is illustrated in FIG.
1
B. Virtual inheritance, i.e. inheritance from a virtual base class, is a primary strength for improving space and run time efficiency of the C++ object model.
FIG. 1C
shows the resulting complete class D
10
corresponding to the inheritance tree of
FIG. 1A
, in which the base class A is not virtual.
FIG. 1D
shows the resulting complete class D
15
corresponding to the inheritance tree of
FIG. 1B
, in which the base class A is virtual. As shown in
FIG. 1D
, virtual base classes are only shared within a complete object, in this case the complete object D
15
. Also shown in
FIG. 1D
is the virtual function table
16
for object D
15
, indicating a virtual function
17
, for example, contained within the virtual base class A.
To use virtual inheritance in a C++ program, the programmer must specify one or more of a class's functions to be virtual. Typically, the complete set of virtual functions available is fixed at compile time and a programmer therefore cannot add or replace any function of the complete set at run time. Accordingly, fast dispatch of virtual function invocations is realized at the cost of run time flexibility. Virtual function calls are generally resolved by indexing into a table (conventionally known as a virtual function table) constructed by the compiler, which holds the addresses of the virtual functions associated with the base class. A fundamental problem of virtual inheritance is to dispatch within the constraints of the C++ object model conventions, the virtual functions at run time with the correct object pointer for the object that is being processed.
More specifically, this problem relates to properly obtaining a pointer which points to a derived class when given a pointer to a virtual base class. In the C++ language such a pointer is referred to as a “this” pointer. The “this” pointer must point to a location in the base class object that contains the function. As a result, adjusting functions are used to obtain a new “this” pointer pointing to the derived class from a “this” pointer pointing to a virtual base class. However, it is difficult to correctly obtain the n
Cesari and McKenna LLP
Compaq Computer Corporation
Maung Zarni
Opie G. Lawrence
LandOfFree
System and method for generating an object structure at run... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with System and method for generating an object structure at run..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and System and method for generating an object structure at run... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2819799