# Klausur 2. Prüfungszeitraum

Objektorientierte Programmierung
Technische Informatik (Bachelor)
Sommersemester 2024
Dauer: 90 Minuten

###### Tragen Sie bitte auf allen Blättern Ihren Namen und Ihre Matrikelnummer ein.

Die Dauer der Klausur beträgt 90 Minuten.

###### Prüfungsvorraussetzungen

Damit diese Klausur bewertet wird, müssen Sie fünf Übungen erfolgreich abgegeben haben. Abgaben von Übungsaufgaben aus vergangenen Semestern werden nur nach individueller Besprechung mit dem Dozenten anerkannt.

###### Zugelassene Hilfsmittel

Sie können einen Taschenrechner (ohne Netzwerk- und Kommunikationsfunktionen), sowie ein beidseitig handgeschriebenen DIN-A4-Zettel benutzen. Weiterhin verwenden Sie eigenes Papier (nur wenn erforderlich) und Schreibutensilien. Weitere Hilfsmittel sind nicht zugelassen.

###### Täuschung und Ordnungsverstöße

Es gibt in diesem Fall §24 der Rahmenstudien- und Prüfungsordnung. Täuschungen und Ordnungsverstöße werden mit der Note 5,0 bewertet und werden dem Prüfungsausschuss gemeldet. Dazu zählen neben der Verwendung von nicht zugelassenen Hilfsmitteln auch die Anfertigung von Kopien dieser Klausur.

###### Bewertung

Die Punkte zu jeder Teilaufgabe sind in Klammern angegeben.
Es gilt die folgende Bewertungsskala:

|  1,0 |   1,3   | 1,7     | 2,0     | 2,3     | 2,7     | 3,0     | 3,3     | 3,7     | 4,0     | 5,0  |
| :--: | :-----: | ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | ---- |
| ≥ 86 | 81 - 86 | 77 - 80 | 72 - 76 | 68 - 71 | 63 - 67 | 59 - 62 | 54 - 58 | 50 - 53 | 45 - 49 | < 45 |

**Erzielte Punkte und Note** (*wird vom Dozenten ausgefüllt*)

```cpp
/*01*/#include <iostream>
/*02*/#include <string>
/*03*/#include <exception>
/*04*/#include <list>
/*05*/
/*06*/class Secret {
/*07*/  private:
/*08*/    std:string s;
/*09*/  public:
/*10*/    Secret() : Secret("password") { }
/*11*/    Secret(const std::string &phrase) : s(phrase) { }
/*12*/    Secret(const Secret &line) = delete;
/*13*/    Secret(Secret &&line) {
/*14*/      s = line.s;
/*15*/      line.s = "";
/*16*/    }
/*17*/
/*18*/    bool check(const Secret &test) const {
/*19*/      return test.s == s;
/*20*/    }
/*21*/
/*22*/    bool check_or_except(const std::string &test) const {
/*23*/      if (this->check(test)) {
/*24*/        return true;
/*25*/      }
/*26*/      else {
/*27*/        throw std::logic_error("Invalid secret given.");
/*28*/      }
/*29*/    }
/*30*/};
/*31*/
/*32*/template<typename T>
/*33*/class Hacker {
/*34*/  private:
/*35*/    const T &rainbow_table;
/*36*/  public:
/*37*/    Hacker(const T &items) : rainbow_table(items) { }
/*38*/    std::string hack(const Secret &secret) const {
/*39*/      for (auto iter = std::begin(rainbow_table); iter != std::end(rainbow_table);
/*40*/           iter++) {
/*41*/        if (secret.check_or_except(*iter)) {
/*42*/          return *iter;
/*43*/        }
/*44*/      }
/*45*/
/*46*/      return "Password unhackable";
/*47*/    }
/*48*/};
/*49*/
/*50*/int main() {
/*51*/  Secret s1("DontGu4ss1T!");
/*52*/  Secret s2 = std::move(s1);
/*53*/  std::list<std::string> common_pass = {"password", "123456", "secret", "geheim"};
/*54*/  std::vector<std::string> secure_pass = {"YdKnmaa!", "LongPassRTh4Best", "DontGu4ss1T!"};
/*55*/
/*56*/  auto cracker1 = new Hacker<std::list<std::string>>(common_pass);
/*57*/  auto cracker2 = new Hacker<std::vector<std::string>>(secure_pass);
/*58*/
/*59*/  std::cout << cracker1->hack(s1) << std::endl;
/*60*/  std::cout << cracker2->hack(s1) << std::endl;
/*61*/  std::cout << cracker1->hack(s2) << std::endl;
/*62*/  std::cout << cracker2->hack(s2) << std::endl;
/*63*/
/*64*/  return 0
/*65*/}
/*66*/
/*67*/
```

## 1. Code-Verständnis (30 Punkte)

Alle Aufgaben in diesem Block beziehen sich auf das Code-Beispiel auf Seite 2 der Klausur. Verwenden Sie gerne Zeilennummern um auf Code-Auszüge Bezug zu nehmen. **Der Code ist syntaktisch korrekt**.
a) **Welche Kllassen** werden in dem Code-Beispiel definiert? (*2 Punkte*)
b) Erläutern Sie Zeile 27 (`throw std::logic_error("Invalid secret given.");`). (*3 Punkte*)
c) Bei der Ausführung der Anwendung **stürzt diese in der Zeile 59** (`std::cout << cracker1->hack(s1) << std::endl;`) ab. Erläutern Sie das Verhalten und beziehen Sie sich auf Zeile 51 (`Secret s1("DontGu4ss1T!");`), 53 (`std::list<std::string> common_pass = {"password", "123456", "secret", "geheim"};`), 56 (`auto cracker1 = new Hacker<std::list<std::string>>(common_pass);`)? (*5 Punkte*)
d) Wie muss die Methode `hack` verändert werden, sodass **keine Exceptions** bei dessen Verwendung mehr auftreten können? (*1 Punkt*)
e) Erläutern Sie den Begriff "**Delegating Constructor**" am Code-Beispiel. Nennen Sie die Zeilennummer, in der ein Delegating Constructor verwendet wird. (*3 Punkte*)
f) Bei **welcher der Klassen** im Code-Beispiel handelt es sich um eine **Template**-Klasse? (*1 Punkt*)
g) Erläutern Sie die Bedeutung von **Zeile 12**. Was sind die **Auswirkungen** für Objekte der Klasse? (*3 Punkte*)
h) Wir nehmen an, Sie haben die Exception in der `hack`-Methode behoben. Wie lautet die **Ausgabe der Zeilen 58-61** (bis `std::cout << cracker1->hack(s2) << std::endl;`) auf dem Bildschirm? (*4 Punkte*)
i) Erläutern Sie, **wie** es zu der **Ausgabe** von Zeile `60` (`std::cout << cracker2->hack(s1) << std::endl;`) kommt. (*4 Punkte*)
j) Erläutern Sie die Funktionen `std::begin` und `std::end` in Zeile 39? (*2 Punkte*)
k) Beschreiben Sie kurz, warum die Methode `check` in Zeile 23 mit der Variablen `test` aufgerufen werden kann, obwohl diese als `std::string` nicht mit dem formalen Parameter `test` der Methode in Zeile 18 übereinstimmt. (*2 Punkte*)

## 2. Grundlagen OOP (20 Punkte)

a) Welches Konzept der OOP beschreibt die **Weitergabe von Eigenschaften und Verhalten** vom Allgemeinen zum Speziellen? (*1 Punkt*)
b) Welches Konzept der OOP beschreibt die Fähigkeit, **unterschiedliches Verhalten** basierend auf dem Verwendungs-Kontext anzubieten? (*1 Punkt*)
c) Erläutern Sie kurz die Begriffe **State**, **Supertyp** und **Getter**. (*3 Punkte*)

```
┌─────┐
│  A  │◁┐
└─────┘ │
   △ ┌──┴──┐
   │ │  B  │
   │ └─────┘
   │    △
   │    │
   │ ┌──┴──┐
   │ │  C  │
   │ └─────┘
┌──┴──┐ △
│  D  ├─┘
└─────┘
```

d) Welche Aussagen zu dem Klassendiagramm oben treffen zu? (*4 Punkte*)

```
- A erbt von B.
- C ist ein Subtyp von A.
- D ist eine Kindklasse von A und C.
- Die Methoden von B können in A verwendet werden.
```

e) Was beschreibt die "**Ist-Ein**"-Beziehung (*2 Punkte*)
f) Was sind **drei Eigenschaften** eines **Interfaces**? (*3 Punkte*)
g) Warum ist der Test auf **Gleichheit von Objekten** (bspw. mittels == in C) **schwierig**? (*2 Punkte*)
h) Um welche **Art von Polymorphismus** handelt es sich bei: (*4 Punkte*)

```
- zwei Funktionen, die den gleichen Namen, aber unterschiedliche formale Parameter besitzen?
- zwei Funktionen mit der gleichen Signatur, die jedoch in Eltern- und Kind-Klasse implementiert sind?
- einem Additions-Operator, welcher Zahlen addiert und Strings verkettet?
- Template-Klassen?
```

i) Erläutern Sie kurz, warum mit OOP, ein neuer **Scope** zur Verfügung steht. Mit welchem **Schlüsselwort** kann in C explizit auf diesen **Scope verwiesen** werden? (*2 Punkte*)
j) Welche Arten von Vererbung gibt es? (*2 Punkte*)

## 3. Erweiterte Sprachkonstrukte (20 Punkte)

a) Was ist ein **Copy-Assignment**? (*1 Punkt*)
b) DRY-Prinzip steht für **Don't Repeat Yourself**, also der Vermeidung von gleichem Code für bspw. unterschiedliche Klassen. Wie kann dieses Prinzip mit OOP umgesetzt werden? (*1 Punkt*)
c) Nennen Sie zwei Datenstrukturen für die **assoziative Speicherung** von Elementen. (*1 Punkt*)
d) Worauf muss bei der **Umwandlung** von Datentypen geachtet werden? (*1 Punkt*)
e) Welches Verhalten wird als **Broadcasting** bezeichnet? (*2 Punkte*)
f) Welche **Garantien** gibt es bei Funktionen hinsichtlich dem Umgang mit **Exceptions**? (*2 Punkte*)
g) Was bedeutet es, wenn eine Anwendung als **ereignisgesteuert** bezeichnet wird? Nennen Sie eine **Gruppe von Anwendungen**, bei denen dieses Paradigma verwendet wird. (*2 Punkte*)
h) Was sind die **Unterschiede** zwischen einem **Forward Iterator**, **Bidirectional Iterator** und **Random Access Iterator**? (*3 Punkte*)
i) Was beschreiben die Ausdrücke **pass-by-value** und **pass-by-reference**? Welches Verfahren ist **effizienter** im Umgang mit Arbeitsspeicher? (*3 Punkte*)
j) Erläutern Sie kurz das **Diamond-Problem**. (*3 Punkte*)

## 4. C++-Programmiersprache (20 Punkte)

a) Was unterscheidet C++-Interfaces von abstrakten Klassen? (*2 Punkte*)
b) Gegeben ist folgender Code-Ausschnitt: (*2 Punkte*)

```cpp
int a = 100;
int b = 200;
int &c = a;
c = b;
/* Welchen Wert haben a, b, und c? */
```

c) An welchen Strukturen können Sie das Schlüsselwort **template** verwenden? (*2 Punkte*)
d) Welche Bedeutung hat das Schlüsselwort **explicit** vor einem Konstruktor? (*2 Punkte*)
e) Nennen Sie drei Unterschiede (außer syntaktischen) zwischen Pointern und Referenzen. (*3 Punkte*)
f) Deklarieren Sie einen **Copy-Konstruktor** für die Klasse `Hacker`, welcher mit einer unveränderlichen Referenz eines anderen Objekts vom Typ `Hacker` verwendet wird. (*2 Punkte*)
g) Erläutern Sie den folgenden Ausdruck und inbesondere auch die Bedeutung der `::`-Symbole (*4 Punkte*)

```cpp
if (s.find("Bahnhof") != std::string::npos)
```

h) Deklarieren Sie eine Klasse "**Paar**", welche **zwei** Template-Argumente **K** und **V** besitzt. (*3 Punkte*)