47 lines
2.6 KiB
Plaintext
47 lines
2.6 KiB
Plaintext
The LPC inherit statement:
|
|
|
|
Syntax: inherit pathname;
|
|
|
|
where pathname is a full path delimited by quotes (e.g. "/std/Object").
|
|
|
|
The 'inherit' statement provides the inheritance capability (a concept from
|
|
object-oriented programming) to LPC objects. Inheritance lets an object
|
|
inherit functions and variables from other objects. Because the MudOSdriver
|
|
internally stores global data and compiled code separately, many different
|
|
objects can use inheritance to share the same piece of compiled code. Each of
|
|
these objects will have its own local copy of any global variables defined
|
|
by the object. Suppose that two object A and B inherit object C. Recompiling
|
|
object either of A or B will not cause C to be recompiled. However, it will
|
|
cause any global variables provided by C to lose whatever data they had
|
|
(remember that A and B each have their own copy of the global variables
|
|
provided by C. Thus updating A will not effect the global variables of B
|
|
(even those provided by C) and vice versa).
|
|
|
|
Suppose object A inherits object B. Object A may define variables and functions
|
|
having the same names as those defined by B. If object A defines a function
|
|
of the same name as one defined by B, then the definition provided by A
|
|
overrides the definition provided by B. If A wishes to access the definition
|
|
provided by B, then it may do so. For example suppose that object A defines
|
|
its own function named query_long and yet wishes to call the query_long
|
|
function provided by the /std/Object.c object. Then A may refer to the
|
|
query_long in Object.c as Object::query_long(). If A defines a variable
|
|
of the same name as a global variable defined in B, then the only way that A
|
|
can access that variable is via functions provided by B. If B defines
|
|
a global variable that is not declared in A, then by default A may use that
|
|
global variable as if the global variable were defined in A (assuming B does
|
|
not choose to restrict access). Note: if object B is recompiled, object A
|
|
will continue to use the old version of object B until object A is also
|
|
recompiled.
|
|
|
|
Multiple inheritance is allowed. That is, an object may inherit more than
|
|
one other object. Suppose special.c inherits weapon.c and armor.c and that
|
|
both weapon.c and armor.c each provide their own version of query_long().
|
|
We may assume that special.c wants to sometimes act like a weapon and
|
|
sometimes act like armor. When special.c is to look like armor it
|
|
can use armor::query_long() and when it is to look like a weapon it
|
|
can use weapon::query_long().
|
|
|
|
See the tutorial named 'types/modifiers' for more information on how
|
|
inherited objects may hide data and function definitions from objects that
|
|
inherit them.
|