RhodeCode

C++ makes it possible to use default parameter values when calling a

function. In such a case we do not have to give value for parameters,

the program will use the default ones.  Unfortunately sometimes this

is not enough. If we do not want to give values for all the

parameters, only for some of them we come across problems, because an

arbitrary set of parameters cannot be omitted. On the other hand

parameters have a fixed order in the head of the function.  C++ can

apply the default values only in the back of the order, if we do not

give other value for them.  So we can not give the function for

example the value of the first, and the third parameter, expecting

that the program will aplly the default value for the second

parameter.  However sometimes we would like to use some functinos

exactly in this way. With a crafty trick and with some little

inconvenience this is possible. We have implemented this little trick

as an example below.

    printf("Here is the function itself.");

The usage is the following.

We have to define a class, let's call it \c namedFn.  Let us assume that

we would like to use a parameter, called \c X. In the \c namedFn class we

have to define an \c _X attribute, and a function \c X. The function

expects a parameter with the type of \c _X, and sets the value of

\c _X. After setting the value the function returns the class itself. The

class also have to have a function, called for example <tt>run()</tt>, we have

to implement here the original function itself. The constructor of the

class have to give all the attributes like \c _X the default values of

them.

If we instantiate this class, the default values will be set for the

attributes (originally the parameters), initially. If we call function

\c X, we get a class with the modified parameter value of

\c X. Therefore we can modify any parameter-value, independently from the

order. To run the algorithm we have to call the <tt>run()</tt> function at the

end of the row.

Example:

a function. That it why it is called namedFn and not \c NamedFn.

\note In fact, the final <tt>.run()</tt> could be made unnecessary if the

actual function code were put in the destructor instead. This however would make

hard to implement functions with return values, and would also make the

implementation of \ref named-templ-func-param "named template parameters"

very problematic. <b>Therefore, by convention, <tt>.run()</tt> must be used

to explicitly execute function having named parameters in Lemon.</b>

The procedure above can also be applied when defining classes. In this

case the type of the attributes can be changed.  Initially we have to

define a class with the default attribute types. This is the so called

Traits Class. Later on the types of these attributes can be changed,

as described below. In our software \ref lemon::DijkstraDefaultTraits is an

example of how a traits class looks like.

the class contains named parameters, we do not have to reinstantiate

the class with new traits class. Instead of that, adaptor classes can

be used like in the following cases.

\section named-templ-func-param Named Function Template Parameters

If the class has so called wizard functions, the new class with the

modified tpye of attributes can be returned by the appropriate wizard

function. The usage of these wizard functions is the following: