allocation_policy.tex

由matlab开发的hybrid系统的描述语言

\chapter{Allocation and Destruction Policy}
\label{alloc_pol_c}

\section{General Policy}

If some object $o$ \emph{belongs} to to an instance $A$ of some
class, then $A$ is the only object who may read or modify $o$. $A$
is also responsible for deleting $o$ when $o$ is no longer needed.
When $A$ calls a method of of another object $B$ (or an operator
of $B$) and gives as an argument a pointer to $o$, then $o$ from
now on belongs to $B$. Similarly, if a method of $A$ returns a
pointer to $o$ to $B$, ownership of $o$ goes to $B$. If $A$ wants
to remain the owner of $o$, it has to copy $o$ before passing it
as argument or returning it.

This scheme guarantees that no two object reference a common
object $o$. Such situations are dangerous, because the two
instances have to coordinate their use of $o$. The problem with
our scheme is that it requires a lot of unnecessary copying. To
reduce this overhead, there are three exceptions:
\begin{enumerate}
\item A function can have a pointer to a constant class as
argument. In that case, the ownership of the passed object does
not change.
\item A function can return a pointer to a constant class as
argument. In that case, the ownership of the returned object does
not change.
\item Private methods do not obey the scheme at all. The class is
supposed to know what it does.
\end{enumerate}


\section{Allocation Policy for Symbols}

Another exception to the above rule is the class
\cppclass{Symbol}. A \cppclass{Symbol} is created by
\cppclass{Symbol\_table}, who is also responsible for its
destruction.  All other classes only get a \code{const Symbol*}
reference to the symbol in the symbol table. Thus it is guaranteed
that a variable is represented by only one instance of
\cppclass{Symbol}.

During the initialization of a symbol the symbol has to be
modified. The following example shows how this is done for setting
the value of a parameter. \cppclass{Param\_symbol} has a method
\method{Param\_symbol}{set\_value}, which sets the value of the
parameter. The method is declared as \code{const}, so it can for
example be used from \cppclass{Item}. Of course a constant method
cannot directly change an attribute. However, it can ask the
symbol table to lookup the symbol with the same name. The symbol
found in the symbol table is not \code{const} and can therefore be
modified. \method{Symbol\_table}{symb\_set\_value} calls
\method{Param\_symbol}{set\_value\_nonconst} for that symbol. This
method can now do the actual work (i.e. set the value).

This design of referencing symbols seems not very elegant. Symbols
are modified far more than was assumed when the design was made. A
future implementation may want to use normal pointers to symbols
instead of \code{const Symbol*}.