\documentstyle[html]{article}
\setlength{\textwidth}{6.6truein}
\setlength{\oddsidemargin}{-.2truein}
\setlength{\evensidemargin}{-.2truein}
\setlength{\textheight}{9truein}
\setlength{\topmargin}{-.4truein}
\setlength{\headsep}{.2truein}
\setlength{\footskip}{.3truein}
\begin{document}

\begin{center}
  {\Large \bf Notes}
\end{center}

\begin{description}

\item[Overloading] Overloaded functions do not have to have the same
  return type.  For example, you can overload a square root function
  to return an \verb^int^ if the argument is \verb^int^ and return a
  \verb^float^ if the argument is \verb^float^.  See:
  \begin{itemize}
  \item Herbert Schildt ``Turbo C++'' p.~730,
  \item K. Ponnambalam and T. Alguindigue ``A C++ Primer for
    Engineers'' p.~85.
  \end{itemize}

\item[References] Ignore most of the lessons ``Changing Parameter
  Values'' and ``Using C++ References''.  The important thing to
  remember is that if a function is called with some parameter, say
  \verb^par^, the function does not usually receive the full
  information about \verb^par^.  In particular, it only receives the
  value that is stored in variable \verb^par^, but no information
  about where the variable \verb^par^ is actually located in memory.
  As a result, the function can use, but not modify the value of
  \verb^par^.

  However, in C++ we can precede the parameter \verb^par^ with an \&
  in the definition of the function, and in its prototypes.  In that
  case, the function will not receive the value of \verb^par^, but the
  actual location where \verb^par^ is stored in memory.  This gives
  the function full access to \verb^par^, and it can now change its
  value. The parameter is now passed ``by reference'', instead of ``by
  value''.

\end{description}
\end{document}
