Lösung der Klausur Pr31 SS'05

Aufgabe 1.

CKnoten& operator+=(CKnoten& that) { … return *this; }
a.operator+=(b.operator+=(c));

CKnoten* operator+=(CKnoten* links, CKnoten* rechts) { … return links; }
operator+=(&a, operator+=(&b, &c));

Aufgabe 2

class FakeWS { public :
	Iterator& iterator() { return *new FakeIterator(); }
	// Iterator* iterator() { return new FakeIterator(); } // alternativ

protected :
       class FakeIterator { private :
             int zaehler;
             string daten[] = { "Technische" "Fachhohschule" "Berlin" };

       public:
             FakeIterator() : zaehler(0) {}
             string akutellesElement() { return daten[zaehler]; }
             void naechstesElement() { zaehler++; }
             boolean mehrElemente() { return zaehler < 2; } } }

Aufgabe 3

Aufgabe 4:

(X) Richtig – Eine Java-Referenz kann nur auf die Halde (heap) zeigen, ein C++-Zeiger kann auch auf den Stapel (stack) zeigen.

Grund: int i; int* p = &i;

(X) Richtig                   Stromoperatoren für eine Klasse können nur programmiert werden,
(X) Falsch                    wenn sie für alle Komponenten (Attributen) der Klasse zur Verfügung stehen.

Grund für Richtig: Alle Komponenten werden im Rumpf des Stromoperators einzeln ausgegeben und eingelesen.

Grund für Falsch: Der Programmierer legt fest, ob alle Komponenten ein- und ausgegeben werden, oder einige nicht.

(X) Falsch – Java-Programme werden ausschließlich dynamisch gebunden, C++-Programme werden ausschließlich statisch gebunden

Grund: Aus C++-Programmen können .dll’s hergestellt werden, die dynamisch gebunden werden.

(X) Richtig – Wenn flache Gleichheit true ergibt, ergibt die tiefe Gleichheit auch true.

Grund: die referenzierten Objekte (untersucht bei tiefer Gleichheit) sind identisch

(X) Falsch – Der Destruktor einer C++-Klasse wird nur bei delete aufgerufen

Grund: Auch am Blockende für Stapelobjekte

(X) Richtig – Ein Kopierkonstruktor hat immer genau einen Parameter.

Grund: Eine konstante Referenz auf das Objekt derselben Klasse

(X) Richtig – Mehrfachvererbung in C++ verursacht Namenskonflikte.

Grund: Oberklassen können Methoden und Variablen mit dem gleichen Namen vererben

(X) Falsch – Der %-Operator in der Implementierung des Ringpuffers sorgt dafür, dass ein belegter Platz im Puffer nicht überschrieben wird.

Grund: Das muss extra überwacht werden. Der %-Operator sorgt für den Überlauf in der Reihung.

Aufgabe 5. 

// zufall.h
#ifndef ZUFALL_H
#define ZUFALL_H
int zufall();
#endif

// zufall.c
#include "zufall.h"
#include "random.hpp"
Random r;
int zufall() {
       return (int) (1000 * r.random()); }