Changeset e72969a

Timestamp:

May 28, 2021, 2:12:34 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

dd2e084

Parents:

c0c8962 (diff), 03c0e44 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• doc/theses/andrew_beach_MMath/existing.tex (modified) (1 diff)

doc/theses/andrew_beach_MMath/existing.tex ¶

@@ -42 +42 @@
 
 \section{Reference Type}
-\CFA adds a rebindable reference type to C, but more expressive than the \Cpp
-reference.  Multi-level references are allowed and act like auto-dereferenced
-pointers using the ampersand (@&@) instead of the pointer asterisk (@*@). \CFA
-references may also be mutable or non-mutable. If mutable, a reference variable
-may be assigned using the address-of operator (@&@), which converts the
-reference to a pointer.
+\CFA adds a reference type to C as an auto-dereferencing pointer.
+They work very similarly to pointers.
+Reference-types are written the same way as a pointer-type is but each
+asterisk (@*@) is replaced with a ampersand (@&@);
+this includes cv-qualifiers and multiple levels of reference.
+
+They are intended for cases where you would want to use pointers but would
+be dereferencing them (almost) every usage.
+In most cases a reference can just be thought of as a pointer that
+automatically puts a dereference infront of each of its uses (per-level of
+reference).
+The address-of operator (@&@) acts as an escape and removes one of the
+automatic dereference operations.
+Mutable references may be assigned to by converting them to a pointer
+with a @&@ and then assigning a pointer too them.
+
+\begin{minipage}{0,5\textwidth}
+With references:
 \begin{cfa}
 int i, j;
-int & ri = i, && rri = ri;
-rri = 3;  // auto-dereference assign to i
-&ri = &j; // rebindable
-ri = 5;   // assign to j
-\end{cfa}
+int & ri = i;
+int && rri = ri;
+rri = 3;
+&ri = &j;
+ri = 5;
+\end{cfa}
+\end{minipage}
+\begin{minipage}{0,5\textwidth}
+With pointers:
+\begin{cfa}
+int i, j;
+int * pi = &i
+int ** ppi = π
+**ppi = 3;
+pi = &j;
+*pi = 5;
+\end{cfa}
+\end{minipage}
 
 \section{Constructors and Destructors}