02-values-references.tex

\input{definitions}

\begin{document}

\title{Values and References}
\subtitle{Russian Roulette with Memory}
\date{\today}
\author{Florian Warg, Max Staff}

\maketitle

\begin{frame}[fragile]
    \frametitle{What are values?}
    \begin{itemize}
        \item values are expressions in a normal form
        \item cannot be reduced or evaluated any further
        \begin{lstlisting}[numbers=none]
1 + 2 // not a value (can be reduced)
3     // value (in normal form)
        \end{lstlisting}
        \item variables can hold values
        \item value is independent from its location
        \begin{lstlisting}[numbers=none]
int x = 2, y = 4, z = 4;
x + y == x + z // 2 + 4 == 2 + 4
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Lvalues}
    \begin{itemize}
        \item lvalues are expressions which can be used on the left side of an assignment operation (and also the right side)
        \item i.e. an lvalue has a memory address
        \begin{lstlisting}[numbers=none]
int x = 1; // x is evaluated to 1
x = 2;     // x is lvalue
2 = x;     // compiler error: 2 is not an lvalue
int y = x; // both x and y are lvalues
        \end{lstlisting}
        \item lvalues persist beyond a single expression
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Rvalues}
    \begin{itemize}
        \item rvalues are non-lvalues
        \item can only be used on the right side of an assignment operation
        \item e.g. temporary variables, literals, addresses are rvalues
        \begin{lstlisting}[numbers=none]
/* temporaries and literals*/
"rvalue"; 
2;
41 + 4;
/* not rvalues */
int x = 1, y = x; // x is lvalue, not rvalue
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{References}
    \begin{itemize}
        \item a reference is an alias for an existing value
        \item there are references for lvalues and rvalues
        \item references are not necessarily objects
        \item i.e. there are no pointers, arrays or references to references
        \item give access to a variable without copying its value
        \item allow modification of local variables in other scopes
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Lvalue references}
    \begin{itemize}
        \item alias which refers to an lvalue
        \begin{lstlisting}
int x = 42;
int& lx = x; // create lvalue reference to x
++lx;        // use alias instead of x
cout << x;   // what is printed here?
        \end{lstlisting}
        \item functions taking lvalue references can modify local variables
        \begin{lstlisting}
void add2(int& ref) { ref += 2; }
int x = 10;
add2(x); // ref is initialized with x
cout << x;
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Rvalue references}
    \begin{itemize}
        \item alias which refers to an rvalue
        \begin{lstlisting}
string&& sr = "Hello";  // create temporary
cout << sr;
        \end{lstlisting}
        \item used to implement move semantics and perfect forwarding
        \item move temporaries into function instead of copying their values
        \begin{lstlisting}
void sinkStr(string&& tmp) { cout << tmp; }
sinkStr("Hello World!");
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Pointers}
    \begin{itemize}
        \item pointers are data types that hold addresses as their values
        \item can be dereferenced: interpret data at address as value
        \item can be used for pointer arithmetics
        \begin{lstlisting}
int x = 42;
int* px = &x; // px holds lvalue (address) of x
cout << px;   // print address
*px = 43;     // set content of variable at &x
cout << *px   // print 43 (value of x)
struct { int x; } t, *pt = &t;
(*pt).x = 1;  // dereference then access member
pt->x = 2;    // preferred shortcut
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Pointer arithmetics}
    \begin{itemize}
        \item addresses are basically numbers
        \item for T* offsets are relative to sizeof(T)
        \item can be used for low level programming and arrays
        \begin{lstlisting}
int arr[12];  // &arr[0] == 0xDEAD0000
int* p = arr; // p = &arr[0]
p + 1;        // 0xDEAD004 with sizeof(int) = 4
p + 3;        // 0xDEAD00C
*p = 1;       // arr[0] = 1
*(p + 1) = 2; // arr[1] = 2
p[11] = 12;   // arr[11] = 12
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Nullpointer}
    \begin{itemize}
        \item a pointer that holds address 0x00 is a nullpointer
        \item C++ has special value called nullptr 
        \item \textbf{never use NULL or 0 instead of nullptr}
        \item dereferencing nullptr is undefined behavior (usually segfault)
        \item testing for nullptr is important
        \begin{lstlisting}
int x = 12;
int* p = &x;
int* np = nullptr;
if (p != nullptr) { cout << "not null"; }
if (!np) { cout << "null"; }
if (p && *p) { cout << *p; }
if (np && *np) { cout << *np; } // no error.
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Value semantics}
    \begin{itemize}
        \item programming style that focuses on values stored in objects
        \item identity of objects is irrelevant
        \item default behavior of C++
        \item mathematical approach
        \item easy to use
        \item no reference aliasing problems: cannot implicitly modify a variable
        \item can be highly optimized with move semantics, copy elision, etc.
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Value semantics: example}
        \begin{lstlisting}
struct Member { string s; };
struct Host { Member m; };
/* ... */
Host host;
Member member;
member.s = "Hello";
host.m = member;
cout << host.m.s; // print "Hello"
member.s = "World";
cout << host.m.s; // print "Hello"
        \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Reference semantics}
    \begin{itemize}
        \item programming style that focuses on object identity
        \item can be accomplished in C++ with references and pointers
        \item object-oriented approach (default behavior of Java)
        \item allows different parties to modify objects
        \item reference aliasing problems can occur
        \item in OOP copying references is usually cheaper than copying values
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Reference semantics: example}
        \begin{lstlisting}
struct Member { string s; };
struct Host { Member* m; };
/* ... */
Host host;
Member member;
member.s = "Hello";
host.m = &member;
cout << host.m->s; // print "Hello"
member.s = "World";
cout << host.m->s; // print "World"
        \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Call by value / reference}
        \begin{lstlisting}
void val(int x)  { ++x;  }
void ref(int& x) { ++x;  }
void ptr(int* x) { ++*x; }
/* ... */
int i = 0;
cout << i; // print 0
val(i);
cout << i; // print 0
ref(i);
cout << i; // print 1
ptr(&i);
cout << i; // print 2
        \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Namespaces}
    \lstinputlisting{examples/01-hello-world.cpp}
    \begin{lstlisting}
using namespace std;
namespace own {
    void otherFunc() { return; }
}
own::otherFunc();
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Namespaces}
    \begin{lstlisting}
void outsider() { return; }

namespace own {
    void firstFunc() { return; }

    namespace second {
        void otherFunc() {
            firstFunc(); ::outsider(); return;
        }
    }
}
own::second::otherFunc();
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Namespaces}
    \begin{lstlisting}
int twice() { return 1; }

namespace own {
    int twice() { return 2; }
    void firstFunc() {
        std::cout << own::twice();
        std::cout << ::twice();
        std::cout << twice();
    }
}

inline namespace own {
    void firstFunc() { return; }
}

firstFunc();
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Namespaces}
    \begin{lstlisting}
#include <iostream>
using std::cout;

int main() {
    cout << "Hello World!\n";
    return 0;
}
    \end{lstlisting}
    \begin{lstlisting}
#include <iostream>
// using namespace std;

int main() {
    std::cout << "Hello World!\n";
    return 0;
}
    \end{lstlisting}
\end{frame}


\end{document}