doc/4.3.generic-programming

   1
   2 Generic Programming
   3 ~~~~~~~~~~~~~~~~~~~
   4
   5   Generic programming is the concept of using the
   6 same code with different types, where eventually the
   7 code is expanded for each type requested.
   8
   9 C++ introduces the notion of template<>.
  10 In lightweight C++, generic programming is achieved
  11 with template macro classes and locallity of typedefs
  12 in a more OOP style.
  13
  14
  15 0a. abstract template classes
  16 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  17
  18   Abstract classes are in reallity just macros expanded
  19 with hierarchy into derrived classes.  For example:
  20
  21         template class XX {
  22                 int foo ()      { return i++; }
  23         };
  24
  25         class A : XX {
  26                 int i;
  27         };
  28
  29 In this example 'A' is the same as if it was declared:
  30
  31         class A {
  32                 int foo ()      { return i++; }
  33                 int i;
  34         };
  35
  36 The class 'XX' is called abstract because it is not really
  37 parsed until it derrives into a real class.
  38
  39
  40 0b. local typedefs
  41 ~~~~~~~~~~~~~~~~~~
  42
  43   A typedef declared inside a class is local to the
  44 class.  Only declarations in the scope of the class
  45 can use its name.  Example:
  46
  47         class A {
  48                 X bar [100];
  49                 typedef int X;
  50                 X foo ();
  51         };
  52
  53         X A.foo ()
  54         {
  55                 X i;
  56                 return i;
  57         }
  58
  59 Local typedefs are parsed before all other declarations.
  60
  61
  62 1. Putting it together
  63 ~~~~~~~~~~~~~~~~~~~~~~
  64
  65   With the two above combined we can make a sample
  66 container template.  Because every declaration in
  67 a template class is abstract, it can use names not
  68 declared yet.
  69
  70         //
  71         // a template using a type 'X'.
  72         // not declared yet
  73         //
  74
  75         template class container {
  76                 X values [100];
  77                 void reset ();
  78                 X &operator [] (int i) {
  79                         return values [i];
  80                 }
  81         };
  82
  83                 // this is abstract -- non existant
  84         void container.reset ()
  85         {
  86                 X x;
  87                 memset (values, 0, sizeof values);
  88         }
  89
  90         //
  91         // make a container of integers
  92         //
  93
  94         class i_container : container {
  95                 typedef int X;
  96         };
  97
  98         //
  99         // make a container of floats
 100         //
 101
 102         class f_container : container {
 103                 typedef float X;
 104         };
 105
 106         //
 107         // a container of container of integers
 108         //
 109
 110         class ci_container : container {
 111                 typedef i_container X;
 112         };
 113
 114         //
 115         // use it
 116         //
 117
 118         int main ()
 119         {
 120                 f_container F;
 121
 122                 F.reset ();
 123                 F [1] = F [32] = 3.14;
 124         }
 125
 126
 127 2. Unique Specializations
 128 ~~~~~~~~~~~~~~~~~~~~~~~~~
 129
 130   lwc implements the keyword 'specialize'.  The syntax of
 131 specialize is:
 132
 133         specialize container { typedef float X; } Obj;
 134
 135 Which will declare an object called "Obj" and will specialize
 136 the container template with floats.  In a way this is equivalent
 137 to an anonymous class:
 138
 139         class : container {
 140                 typedef float X;
 141         } Obj;
 142
 143 But there is also a difference.  With specialize, lwc will not
 144 re-specialize the template if it has been specialized before
 145 with this type.
 146
 147 This is extremely useful for templates in templates where
 148 the types depend on the outer types.  For example:
 149
 150         template class TwoContainers {
 151                 specialize container { typedef T1 X; } Cont1;
 152                 specialize container { typedef T2 X; } Cont2;
 153         };
 154
 155         specialize TwoContainers { typedef int T1, T2; } IntIntObj1;
 156
 157         specialize TwoContainers { typedef int T1;
 158                 typedef float T2; } IntFloatObj1;
 159
 160 Here, although there are three requests to specialize a container
 161 with 'int's, lwc will only specialize it once, give it a special
 162 name and use this name the next two times.
 163
 164 This is also helpful in the case of a container of containers:
 165
 166         specialize container {
 167                 typedef specialize container {
 168                         typedef int X;
 169                 } X;
 170         }
 171
 172 3. Default types
 173 ~~~~~~~~~~~~~~~~
 174
 175 In a hierarchy of template classes, the most recent typedef
 176 declaration wins.  For example:
 177
 178         template class A {
 179                 typedef int X;  // default type unless overrriden
 180                 X values [100];
 181         };
 182
 183         specialize A {} Obj1;
 184         specialize A { typedef float X; } Obj2;
 185
 186 Here, Obj1 has an array of integers and Obj2 an array of floats.
 187
 188
 189 4. Warning
 190 ~~~~~~~~~~
 191
 192 This is still an experimental feature.  Some weird corner cases may
 193 not work as they have not been tested.  If lwc complains or gives
 194 incorrect code, send e-mail to the list.