03-namespaces-overloading.tex

\input{definitions}

\begin{document}

\title{Namespaces and Function overloading}
\subtitle{Name collisions and how to avoid them}
\date{\today}
\author{Florian Warg, Max Staff}

\maketitle

\begin{frame}[fragile]
    \frametitle{Name collisions}
    \begin{itemize}
        \item a project uses libraries A and B
        \item A and B offer functions with similar names and arguments
        \begin{lstlisting}[numbers=none]
/* Library A */
digest hash(block input) { return md5(input); }
/* Library B */
digest hash(block input) { return sha1(input); }
/* User code */
hash(my_message);
        \end{lstlisting}
        \item the compiler cannot deduce which function you want to call
        \item this is called a name collision
        \item it will cause a compiler error
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Namespaces}
    \begin{itemize}
        \item libraries use namespaces to avoid name collisions 
        \item namespaces can contain functions, types and objects
        \item symbols can be accessed with ns::symbol
        \begin{lstlisting}[numbers=none]
namespace LibA {
    digest hash(block input);
}
namespace LibB {
    digest hash(block input);
}
/* call hash from Lib A */
LibA::hash(my_message);
/* call hash from Lib B */
LibB::hash(my_message);
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Nested namespaces}
    \begin{itemize}
        \item namespaces can also contain other namespaces
        \item this can be used to organize software into packages
        \begin{lstlisting}[numbers=none]
namespace Lib {
    namespace crypto {
        digest hash(block input) { ... }
    }
}
Lib::crypto::hash(my_message);
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Split namespaces}
    \begin{itemize}
        \item namespaces can be opened and closed at any point
        \item symbols inside the same namespace are visible to each other
        \begin{lstlisting}[numbers=none]
namespace A {
    int x;
} /* namespace A */

namespace A {
    int y;
} /* namespace A */
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Import symbols}
    \begin{itemize}
        \item symbols can be imported into the local namespace
        \item achieved with a "using directive"
        \begin{lstlisting}
#include <string>
using std::string;
int main() {
    std::string s1;
    string s1; // imported std::string as string
}
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Import namespaces}
    \begin{itemize}
        \item whole namespaces can be imported, too
        \item this will import all symbols
        \begin{lstlisting}
#include <iostream>
#include <string>
using namespace std;
int main() {
    string name; // std::string
    cin >> name; // std::cin
    cout << "Hello, " << name << "\n";
}
        \end{lstlisting}
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Best practice}
    \begin{itemize}
        \item global namespace should have as few symbols as possible
        \item never import symbols in header files
        \item full symbol name is easier to understand in code reviews
        \item import single symbols rather than namespaces
        \item in production code almost always use full names
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Scopes}
    \begin{itemize}
        \item each name in C++ has restricted validity (function, namespace)
        \item a scope is the portion of source code where a certain name (e.g. variable) is present
        \item begins at declaration
        \item ends at closing curly brace
        \item what about custom scopes?
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Block Scope}
    \begin{lstlisting}
int main() {
    int a = 0; ++a;
    {
        int a = 1;
        a = 42;
    }
    std::cout << a << "\n"; // ?
}
int b = a; // Error?
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Function Overloading}
    \begin{itemize}
        \item two functions to achieve the same goal for different arguments
        \item example: outputting to command line with std::cout
        \item what about optional parameters with default values?
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Default Arguments}
    \begin{lstlisting}
float round(float a, float b = 1) {
    return a - (a % b);
}

round(10.5);
round(11.3579, 0.1);
round(12345f, 10f);

// this is incorrect:
float round(float b = 1, float a) {
    return a - (a % b);
}
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Different amount of Arguments}
    \begin{lstlisting}
float distance(float a, float b) {
    return std::sqrt(a*a + b*b);
}

float distance(float a, float b, float c) {
    return std::sqrt(a*a + b*b + c*c);
}

distance(5, 3);
distance(5, 3, 7);
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Different type of Arguments}
    \begin{lstlisting}
float round(float a, float b = 1) {
    return a - (a % b);
}

int round(int a, int b = 1) {
    return a - (a % b);
}

round(5.7);
round(4.222, 0.1);
round(355);
round(12345, 10);
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Conclusions}
    \begin{itemize}
        \item in C++ not only the function name is relevant
        \item compiler also checks arguments and return type
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Classes}
    \begin{itemize}
        \item having functions for own datatype assigned to it would improve readability of code
        \item what about OOP? About private and public? And all those more or less complicated design patterns?
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Class declarations}
    \begin{lstlisting}
class Rectangle {
    int width, height;
public:
    int area();
}

int Rectangle::area() {
    return this->width * height;
}

Rectangle a;
a.area();
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Constructors}
    \begin{lstlisting}
class Rectangle {
    int width, height;
public:
    Rectangle();
    int area();
}

Rectangle::Rectangle() {
    this->width = 0;
    this->height = 0;
}

    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Constructors}
    \begin{lstlisting}
class Rectangle {
    int width, height;
public:
    Rectangle(int a, int b);
    int area();
}

Rectangle::Rectangle(int width, int height) {
    this->width = width;
    this->height = height;
}
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Constructors}
    \begin{lstlisting}
class Rectangle {
    int width, height;
public:
    Rectangle(int a, int b);
    int area();
}

int Rectangle::area() { return this->width * height; }

Rectangle::Rectangle(int a, int b) :
    width(a), height(b) {}

Rectangle a;
a.area();
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{RAII}
    \begin{itemize}
        \item Constructor gets called on declaration!
        \item keyword new creates object on heap
        \begin{itemize}
            \item needs to be freed later with delete!
            \item item does not get deleted when going out of scope
        \end{itemize}
        \item benefits: can't forget to call constructor
        \item also we can use destructors now
    \end{itemize}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Destructors}
    \begin{lstlisting}
class Rectangle {
    int width, height;
    FILE* secretLogForNSA;
public:
    Rectangle();
    ~Rectangle();
}

Rectangle::Rectangle() {
    secretLogForNSA = fopen("log.txt", "wa");
}

Rectangle::~Rectangle() {
    fclose(secretLogForNSA);
}
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Inheritance}
    \begin{lstlisting}
class A {
public: int data;
private: int privateData;
}

class B : public A {
public: int metaData;
}

class C : private A {
public: int otherData;
}

A a; a.data;
B b; b.data;
C c; c.data;
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Multiple Inheritances}
    \begin{lstlisting}
class A {
public: int data;
}

class B {
public: int metaData;
}

class C : private A, public B {
public: int otherData;
}
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{Friends}
    \begin{lstlisting}
class B;

class A {
friend B;
private: int data;
}

class B {
private:
    int metaData;
    A other;
public:
    int data() { return this->other.data; }
}
    \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
    \frametitle{New and Delete}
    \begin{lstlisting}
class A {
private: int data;
}

// put object of type A in heap:
A* a = new A();
delete a;
    \end{lstlisting}
\end{frame}

\end{document}