christian/uni
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add ipi8

Browse Source
This commit is contained in:
christian
2019-12-15 18:57:15 +01:00
parent 285e74cef5
commit ea3ea7d4d8
3 changed files with 495 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ws2019/ipi/uebungen/ipi8.pdf
BIN
View File
Binary file not shown.
ws2019/ipi/uebungen/ipi8.tex
+285
View File
@@ -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}
ws2019/ipi/uebungen/listclass.cpp
+210
View File
@@ -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;
}