doc/6.0.new-in.1.0

   1
   2 new stuff of lwc 1.0
   3 ********************
   4
   5 Also in 1.0: regular expressions and ctors of arrays
   6
   7 1. Postfix functional operator
   8 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9
  10   'postfix' is a reserved word.  The syntax of 'postfix' is
  11 like a function and it has the effect that: arguments are
  12 evaluated from left to right, the return value is the leftmost
  13 argument (the first one evaluated).  So postfix can remember
  14 for us.  For example:
  15
  16         // the same as x++
  17         postfix (x, x += 1);
  18
  19         // typical useful case
  20         p = postfix (p->next, free (p));
  21         // .. or if ~ is overloaded to call free() on pointers
  22         p = postfix (p->next, ~p);
  23
  24         // increment y by 23 after using the value
  25         postfix (foo (y), y += 23);
  26         // or
  27         foo (postfix (y, y += 23));
  28
  29         // do cleanups
  30         return postfix (do_calculate (buffer), free (buffer), release_semaphore ());
  31
  32         // put new value
  33         x = postfix (strdup (y), free (x));
  34
  35         // the result is x,
  36         postfix (postfix (x, x -= 10), z [x] = 0);
  37
  38         // the result is B
  39         postfix ((A, B), (C, D));
  40
  41 Generally, postfix is a very cool thing and opens a whole
  42 new chapter of possibilities in C expressions and statements.
  43
  44
  45 2. Escape raw strings
  46 ~~~~~~~~~~~~~~~~~~~~~
  47
  48   This is mainly useful to avoid the backslash nightmares when
  49 passing regular expression recipes to regexp libraries.
  50 In order to pass the regexp "\w\s\"\\", we'd have to write
  51 the string "\\w\\s\\\"\\\\". A nightmare.
  52
  53 String literals where a 'r' is placed right before the opening
  54 double quote, don't have this problem since the lwc preprocessors
  55 will escape all backslashes in them.  For example:
  56
  57         char msg [] = r"\w\s\"\\";
  58
  59 will be converted by lwc to:
  60
  61         char msg [] = "\\w\\s\\\"\\\\";
  62
  63 and after the C compiler sees it, will be converted back to "\w\s\"\\"
  64
  65
  66 3. Single quoted strings
  67 ~~~~~~~~~~~~~~~~~~~~~~~~
  68
  69  Because single quotes are fun, it's possible to have string literals
  70 in single quotes.  The way to distinguish between a string and a character
  71 constant is the number of letters.  Single-quoted strings must have more
  72 than 4 characters. Example:
  73
  74         char msg [] = 'Hello World!';
  75         char x [] = '"What do you want?", said Elwood';
  76         char y [] = 'a';        // WRONG!! 'a' remains 'a'
  77
  78
  79 4. References
  80 ~~~~~~~~~~~~~
  81
  82  References have been implemented and can be applied on global and local
  83 variables, structure members, function arguments and virtual variables.
  84 References are "pointers in disguise", they are an alias for a variable.
  85 Whatever we do on references happens on the variable they're pointing
  86 to.  For example:
  87
  88         int foo ()
  89         {
  90                 int i, j;
  91                 // ri is an 'alias' of i
  92                 int &ri = i;
  93                 int &rj = j;
  94
  95                 // same as i = 0
  96                 ri = 0;
  97
  98                 // same as i++
  99                 ri++;
 100
 101                 // same as i = j
 102                 ri = rj;
 103         }
 104
 105   In lwc it is possible to reassign references.  Normally, this is impossible
 106 -as in C++- because the operations on references always happen for the
 107 things they're pointing at and references can be set only once at their
 108 initialization.  Lwc implements a new unary prefix operator called
 109 'dereference'.  When 'dereference' is applied on an expression, all
 110 references in it are treated as pointers.  Extending the previous example:
 111
 112         int foo ()
 113         {
 114                 ....
 115
 116                 // make ri point to j
 117                 dereference (ri) = &j;
 118
 119                 // assign reference to reference
 120                 dereference (ri = rj);
 121                 // or same thing
 122                 dereference ri = dereference rj;
 123         }
 124
 125   The best way to understand all these are by compiling the above code and
 126 looking at the output. 'dereference' is needed since in lwc we don't have
 127 C++'s initialization lists at the constructors of objects.  So the only
 128 way to initialize reference members of objects is with the use of
 129 dereference in the ctor.
 130
 131 The exception is structure arguments. Because lwc passes all structures
 132 by reference anyway (and adjust that pointers and objects can be passed),
 133 declaring references of structures in function arguments, is obsolete,
 134 untested and will confuse the lwc preprocessor in function overloading.
 135
 136 5. Overloaded operators on 'this'
 137 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 138
 139 See 4.2-operator-overloading.
 140 Generally, if for example, the [] operator is overloaded
 141 for a class, the expression:
 142
 143         this [1];
 144
 145 will invoke operator overloading and not pointer displacement.