diff --git a/ws2019/ipi/uebungen/ipi8.pdf b/ws2019/ipi/uebungen/ipi8.pdf
new file mode 100644
index 0000000..3f3ba5d
Binary files /dev/null and b/ws2019/ipi/uebungen/ipi8.pdf differ
diff --git a/ws2019/ipi/uebungen/ipi8.tex b/ws2019/ipi/uebungen/ipi8.tex
new file mode 100644
index 0000000..ed695ca
--- /dev/null
+++ b/ws2019/ipi/uebungen/ipi8.tex
@@ -0,0 +1,285 @@
+\documentclass[uebung]{../../../lecture}
+
+\title{IPI: Übungsblatt 8}
+\author{Samuel Weidemaier, Christian Merten}
+
+\usepackage[]{listings}
+
+\usepackage{xcolor}
+ 
+\lstdefinestyle{mystyle}{
+    commentstyle=\color{gray},
+    language=C++,
+    keywordstyle=\color{blue},
+    numberstyle=\tiny\color{gray},
+    stringstyle=\color{black},
+    basicstyle=\ttfamily\footnotesize,
+    breakatwhitespace=false,         
+    breaklines=true,                 
+    captionpos=b,                    
+    keepspaces=true,                 
+    numbers=left,                    
+    numbersep=5pt,                  
+    showspaces=false,                
+    showstringspaces=false,
+    showtabs=false,                  
+    tabsize=2
+}
+ 
+\lstset{style=mystyle}
+
+
+\begin{document}
+
+\punkte
+
+\begin{aufgabe} Konstruktoren
+
+\begin{tabular}{llllllllllll}
+    \textbf{37}: & a int-Konstruktor & b int-Konstruktor \\
+    \textbf{38}: & c Copy-Konstruktor & d Konstruktor & e Konstruktor \\
+    \textbf{39}: & d int-Zuweisung \\
+    \textbf{40}: & T Copy-Konstruktor & T Addition & U int-Konstruktor & V Copy-Konstruktor
+    & U Destruktor \\
+    & W Copy-Konstruktor & V Destruktor & d Zuweisung & W Destruktor & T Destruktor\\
+    \textbf{41}: & d Addition & T int-Konstruktor & U Copy-Konstruktor & T Destruktor & U Addition \\
+    & V int-Konstruktor & W Copy-Konstruktor & V Destruktor & e Zuweisung & W Destruktor\\
+    & U Destruktor \\
+    \textbf{42}: & e Destruktor & d Destruktor & c Destruktor & b Destruktor & a Destruktor \\
+\end{tabular}
+
+\end{aufgabe}
+
+\begin{aufgabe}
+    \begin{enumerate}[(a)]
+        \item Der Implementierung liegt weiterhin eine einfach verkettete Liste zu Grunde. Konkret
+            wird die \lstinline{struct IntListElem} verwendet.
+            
+            Es wird ein Zeiger \lstinline{IntListElem* first} auf das erste Listenelement, eine
+            Variable \lstinline{int count}, die die Länge der Liste speichert und zwei Hilfsmethoden,
+            \lstinline{IntListElem* getListElement(int position)}, die einen Zeiger auf das interne
+            Listenelement zurückgibt und \lstinline{void copy(IntList& other)}, die die Listenelemente
+            von einer anderen Liste kopiert, verwendet.
+
+            Der leere Konstruktor setzt \lstinline{first} und \lstinline{count} auf 0, genauso wie
+            der Destruktor. Dies führt zur Initialisierung bzw. Leerung der Liste. Der Copy-Konstruktor
+            bzw. Zuweisungsoperator initialisieren bzw. leeren die Liste ebenfalls zunächst und
+            kopieren dann mithilfe der \lstinline{copy} Methode, die Elemente einer zweiten Liste.
+        \item 
+
+    \begin{lstlisting}[language=C++, title=listclass.cpp, captionpos=b]
+#include<stdio.h>
+
+// a list element
+struct IntListElem {
+    int value; // int value
+    IntListElem* next; // pointer to the next element
+};
+
+// A list of integers
+// Beware: indexing is done starting from 1 as the excercise sheet requests it
+class IntList {
+public:
+    // empty constructor, creates an empty list
+    IntList();
+    
+    // copy constructor, intializes by copying from 'other'
+    IntList(IntList& other);
+
+    // assignment operator, removes own elements and copies from 'other'
+    IntList& operator=(IntList& other);
+
+    // destructor, removes list content
+    ~IntList();
+
+    // returns the number of elements in the list
+    int getCount();
+
+    // returns if the list is empty
+    bool isEmpty();
+
+    // prints the list
+    void print();
+
+    // inserts 'element' in the beginning of the list
+    void insert(int element);
+
+    // inserts 'element' AFTER 'position'
+    void insert(int element, int position);
+
+    // removes the element AFTER 'position'
+    void remove(int position);
+
+    // returns the element AT 'position'
+    int getElement(int position);
+private:
+    // pointer to first element
+    IntListElem* first;    
+    // element count
+    int count;
+
+    // returns the IntListElem AT 'position'
+    IntListElem* getListElement(int position);
+
+    // Kopiert die Liste 'other'
+    void copy(IntList& other);
+};
+
+// creates new empty list
+IntList::IntList() {
+    first = 0;
+    count = 0;
+}
+
+// creates a new list by copying an old one
+IntList::IntList(IntList& list) {
+    copy(list);
+}
+
+// Assignment operator
+IntList& IntList::operator=(IntList& other) {
+    if (this == &other) { // if assigning to the same object
+        return *this; // do nothing
+    }
+    copy(other); // otherwise copy contents
+    return *this; 
+}
+
+// destroys the list
+IntList::~IntList() {
+    first = 0; // remove the connection to the list elements
+    count = 0; // reset list count
+};
+
+// private helper that copies from 'other' list
+void IntList::copy(IntList& other) {
+    // clear and copy elements
+    first = 0;
+    count = 0;
+    // copy element by element from 'other' to this new list
+    for (int i = 1; i <= other.count; i++) {
+        insert(other.getElement(i), i-1);
+    }
+}
+
+// private helper that returns the list element struct AT 'position'
+IntListElem* IntList::getListElement(int position) {
+    IntListElem* current = first;
+    for (int i = 1; i < position; i++) {
+        // if list is not long enough
+        if (current->next == 0) {
+            // return the last element
+            return current;
+        }
+        current = current->next;
+    }
+    return current;
+}
+
+// return element AT 'position'
+int IntList::getElement(int position) {
+    if (position < 1 || position > count) {
+        printf("Error: Index out of Bounds, no element at position %d\n", position);
+        return -1;
+    }
+    return getListElement(position)->value; // return the value of the element
+}
+
+// insert 'element' AFTER 'position'
+void IntList::insert(int element, int position) {
+    if (position < 0 || position > count) { // check for invalid positions
+        printf("Error: Index out of Bounds, can't insert.\n");
+        return;
+    }
+    IntListElem* elem = new IntListElem(); // create a new list element
+    elem->value = element; // with the given value
+    if (position == 0) { // insert in the very beginning
+        elem->next = first; // the successor of elem is the old first, now second element
+        first = elem; // make the new element the new first
+    } else {
+        IntListElem* where = getListElement(position); // find the element to insert after
+        elem->next = where->next; // make the old successor of where now follow elem
+        where->next = elem; // make elem the new successor of where
+    }
+    count += 1;
+    return;
+}
+
+// insert 'element' in the very beginning of the list
+void IntList::insert(int element) {
+    insert(element, 0); // insert AFTER position 0
+}
+
+// remove next element AFTER 'position'
+void IntList::remove(int position) {
+    if (position < 0 || position >= count) { // check for invalid positions
+        printf("Error: Index out of bounds, can't remove after %d\n", position);
+        return;
+    }
+    if (position == 0) { // remove first element
+        first = first->next; // new first is the new element
+    } else {
+        IntListElem* where = getListElement(position); // find the element to remove after
+        where->next = where->next->next; // remove by skipping the next element of where
+    }
+    count -= 1; // reduce element count
+    return;
+}
+
+// check if list is empty
+bool IntList::isEmpty() {
+    return count == 0;
+}
+
+// returns the list's size
+int IntList::getCount() {
+    return count;
+}
+
+// print a list of integers
+void IntList::print() {
+    printf("["); // opening brackets
+    IntListElem* current = first;
+    while (current != 0) { // while not last element
+        printf("%d", current->value); // print value
+        if (current->next != 0) {
+            printf(", "); // if not the last element, append a comma
+        }
+        current = current->next; // go to next
+    }
+    printf("]\n"); // closing brackets
+}
+
+int main() {
+    IntList list;
+    list.insert(30);
+    list.insert(20);
+    list.insert(10);
+    list.print();
+
+    list.remove(2);
+    list.print();
+
+    list.insert(30,2);
+    list.print();
+
+    list.insert(40,3);
+    list.print();
+
+    IntList copy(list);
+    copy.print();
+
+    copy.remove(0);
+    copy.print();
+    list.print();
+
+    copy = list;
+    copy.print();
+
+    return 0;
+}
+    \end{lstlisting}
+    \end{enumerate}
+\end{aufgabe}
+
+\end{document}
diff --git a/ws2019/ipi/uebungen/listclass.cpp b/ws2019/ipi/uebungen/listclass.cpp
new file mode 100644
index 0000000..78a7dc8
--- /dev/null
+++ b/ws2019/ipi/uebungen/listclass.cpp
@@ -0,0 +1,210 @@
+#include<stdio.h>
+
+// a list element
+struct IntListElem {
+    int value; // int value
+    IntListElem* next; // pointer to the next element
+};
+
+// A list of integers
+// Beware: indexing is done starting from 1 as the excercise sheet requests it
+class IntList {
+public:
+    // empty constructor, creates an empty list
+    IntList();
+    
+    // copy constructor, intializes by copying from 'other'
+    IntList(IntList& other);
+
+    // assignment operator, removes own elements and copies from 'other'
+    IntList& operator=(IntList& other);
+
+    // destructor, removes list content
+    ~IntList();
+
+    // returns the number of elements in the list
+    int getCount();
+
+    // returns if the list is empty
+    bool isEmpty();
+
+    // prints the list
+    void print();
+
+    // inserts 'element' in the beginning of the list
+    void insert(int element);
+
+    // inserts 'element' AFTER 'position'
+    void insert(int element, int position);
+
+    // removes the element AFTER 'position'
+    void remove(int position);
+
+    // returns the element AT 'position'
+    int getElement(int position);
+private:
+    // pointer to first element
+    IntListElem* first;    
+    // element count
+    int count;
+
+    // returns the IntListElem AT 'position'
+    IntListElem* getListElement(int position);
+
+    // Kopiert die Liste 'other'
+    void copy(IntList& other);
+};
+
+// creates new empty list
+IntList::IntList() {
+    first = 0;
+    count = 0;
+}
+
+// creates a new list by copying an old one
+IntList::IntList(IntList& list) {
+    copy(list);
+}
+
+// Assignment operator
+IntList& IntList::operator=(IntList& other) {
+    if (this == &other) { // if assigning to the same object
+        return *this; // do nothing
+    }
+    copy(other); // otherwise copy contents
+    return *this; 
+}
+
+// destroys the list
+IntList::~IntList() {
+    first = 0; // remove the connection to the list elements
+    count = 0; // reset list count
+};
+
+// private helper that copies from 'other' list
+void IntList::copy(IntList& other) {
+    // clear and copy elements
+    first = 0;
+    count = 0;
+    // copy element by element from 'other' to this new list
+    for (int i = 1; i <= other.count; i++) {
+        insert(other.getElement(i), i-1);
+    }
+}
+
+// private helper that returns the list element struct AT 'position'
+IntListElem* IntList::getListElement(int position) {
+    IntListElem* current = first;
+    for (int i = 1; i < position; i++) {
+        // if list is not long enough
+        if (current->next == 0) {
+            // return the last element
+            return current;
+        }
+        current = current->next;
+    }
+    return current;
+}
+
+// return element AT 'position'
+int IntList::getElement(int position) {
+    if (position < 1 || position > count) {
+        printf("Error: Index out of Bounds, no element at position %d\n", position);
+        return -1;
+    }
+    return getListElement(position)->value; // return the value of the element
+}
+
+// insert 'element' AFTER 'position'
+void IntList::insert(int element, int position) {
+    if (position < 0 || position > count) { // check for invalid positions
+        printf("Error: Index out of Bounds, can't insert.\n");
+        return;
+    }
+    IntListElem* elem = new IntListElem(); // create a new list element
+    elem->value = element; // with the given value
+    if (position == 0) { // insert in the very beginning
+        elem->next = first; // the successor of elem is the old first, now second element
+        first = elem; // make the new element the new first
+    } else {
+        IntListElem* where = getListElement(position); // find the element to insert after
+        elem->next = where->next; // make the old successor of where now follow elem
+        where->next = elem; // make elem the new successor of where
+    }
+    count += 1;
+    return;
+}
+
+// insert 'element' in the very beginning of the list
+void IntList::insert(int element) {
+    insert(element, 0); // insert AFTER position 0
+}
+
+// remove next element AFTER 'position'
+void IntList::remove(int position) {
+    if (position < 0 || position >= count) { // check for invalid positions
+        printf("Error: Index out of bounds, can't remove after %d\n", position);
+        return;
+    }
+    if (position == 0) { // remove first element
+        first = first->next; // new first is the new element
+    } else {
+        IntListElem* where = getListElement(position); // find the element to remove after
+        where->next = where->next->next; // remove by skipping the next element of where
+    }
+    count -= 1; // reduce element count
+    return;
+}
+
+// check if list is empty
+bool IntList::isEmpty() {
+    return count == 0;
+}
+
+// returns the list's size
+int IntList::getCount() {
+    return count;
+}
+
+// print a list of integers
+void IntList::print() {
+    printf("["); // opening brackets
+    IntListElem* current = first;
+    while (current != 0) { // while not last element
+        printf("%d", current->value); // print value
+        if (current->next != 0) {
+            printf(", "); // if not the last element, append a comma
+        }
+        current = current->next; // go to next
+    }
+    printf("]\n"); // closing brackets
+}
+
+int main() {
+    IntList list;
+    list.insert(30);
+    list.insert(20);
+    list.insert(10);
+    list.print();
+
+    list.remove(2);
+    list.print();
+
+    list.insert(30,2);
+    list.print();
+
+    list.insert(40,3);
+    list.print();
+
+    IntList copy(list);
+    copy.print();
+
+    copy.remove(0);
+    copy.print();
+    list.print();
+
+    copy = list;
+    copy.print();
+
+    return 0;
+}