3 \page named-param Named Parameters
5 \section named-func-param Named Function Parameters
7 C++ makes it possible to use default parameter values when calling a
8 function. In such a case we do not have to give value for parameters,
9 the program will use the default ones. Unfortunately sometimes this
10 is not enough. If we do not want to give values for all the
11 parameters, only for some of them we come across problems, because an
12 arbitrary set of parameters cannot be omitted. On the other hand
13 parameters have a fixed order in the head of the function. C++ can
14 apply the default values only in the back of the order, if we do not
15 give other value for them. So we can not give the function for
16 example the value of the first, and the third parameter, expecting
17 that the program will aplly the default value for the second
18 parameter. However sometimes we would like to use some functinos
19 exactly in this way. With a crafty trick and with some little
20 inconvenience this is possible. We have implemented this little trick
31 named_fn() : _id(0), _val(1), _dim(2) {}
32 named_fn& id(int p) { _id = p ; return *this; }
33 named_fn& val(double p) { _val = p ; return *this; }
34 named_fn& dim(int p) { _dim = p ; return *this; }
37 printf("Here is the function itself.");
43 The usage is the following.
45 We have to define a class, let's call it \c named_fn. Let us assume that
46 we would like to use a parameter, called \c X. In the \c named_fn class we
47 have to define an \c _X attribute, and a function \c X. The function
48 expects a parameter with the type of \c _X, and sets the value of
49 \c _X. After setting the value the function returns the class itself. The
50 class also have to have a function, called for example <tt>run()</tt>, we have
51 to implement here the original function itself. The constructor of the
52 class have to give all the attributes like \c _X the default values of
55 If we instantiate this class, the default values will be set for the
56 attributes (originally the parameters), initially. If we call function
57 \c X, we get a class with the modified parameter value of
58 \c X. Therefore we can modify any parameter-value, independent from the
59 order. To run the algorithm we have to call the <tt>run()</tt> function at the
64 named_fn().id(3).val(2).run();
67 \section traits-classes Traits Classes
69 The procedure above can also be applied when defining classes. In this
70 case the type of the attributes can be changed. Initially we have to
71 define a class with the default attribute types. This is the so called
72 Traits Class. Later on the types of these attributes can be changed,
73 as described below. In our software \ref lemon::DijkstraDefaultTraits is an
74 example of how a traits class looks like.
76 \section named-templ-param Named Class Template Parameters
78 If we would like to change the type of an attribute in a class that
79 was instantiated by using a traits class as a template parameter, and
80 the class contains named parameters, we do not have to reinstantiate
81 the class with new traits class. Instead of that, adaptor classes can
82 be used like in the following cases.
85 Dijkstra<>::SetPredNodeMap<NullMap<Node,Node> >
88 It can also be used in conjunction with other named template
89 parameters in arbitrary order.
92 Dijkstra<>::SetDistMap<MyMap>::SetPredMap<NullMap<Node,Edge> >
95 The result will be an instantiated Dijkstra class, in which the
96 DistMap and the PredMap is modified.
98 \section named-templ-func-param Named Function Template Parameters
100 If the class has so called wizard functions, the new class with the
101 modified tpye of attributes can be returned by the appropriate wizard
102 function. The usage of these wizard functions is the following: