Lösung der Klausur Prg31 SS'06

Aufgabe 1.

bool CStapel::enthaelt(const int wert) {
   for (int i = 0; i <= spitze; i++)
     if (wert == inhalt[i]) return true;
   return false; }

Aufgabe 2.

class CWarteschlange { private:
   int anzahl, aeltestes, juengstes, laenge; int* inhalt;
   friend CWarteschlange& operator++(CWarteschlange&); … };

CWarteschlange& operator++(CWarteschlange& ws) { // friend nicht nötig
   if (!ws.istLeer()) {
      int straefling = ws.lesen(); ws.entfernen(); ws.eintragen(straefling); }
   return ws; }

CWarteschlange& operator++(CWarteschlange& ws) { // friend nötig
   if (ws.anzahl > 0) {
      int straefling = ws.inhalt[ws.aeltestes];
      ws.aeltestes = (ws.aeltestes + 1) % ws.laenge;
      ws.juengstes = (ws.juengstes + 1) % ws.laenge;
      ws.inhalt[ws.juengstes] = straefling; }
   return ws; }

Aufgabe 4.

Klasse objekt; // Stapelobjekt
Klasse* zeiger = new Klasse; // Haldenobjekt

class AndereKlasse {
   Klasse objekt; // eingebettetes Objekt
   Klasse* zeiger = new Klasse; } // referenziertes Objekt

Aufgabe 5.

(X) Richtig – Ein C++-Compiler kann auch Bytecode erstellen.
Grund: .NET’s C++-Compiler erzeugt MSIL (ähnlich wie Bytecode)

(X) Falsch – In C++ wird immer statisch gebunden.
Grund: Bei DLL wird dynamisch gebunden

(X) Falsch – Der private Teil der Header-Datei wird erst beim Binden benötigt.
Grund: Nein, auch der Compiler braucht ihn – sonst könnte er in den Rumpf platziert werden.

(X) Falsch – cout ist ein Operator der Klasse ostream, der im iostream.h vereinbart wurde.
Grund: cout ist kein Operator, sondern ein Objekt der Klasse ostream, das im iostream.h vereinbart wurde.

(X) Richtig – Aus Referenzgleichheit folgt immer tiefe Gleichheit.
Grund: ein Objekt ist mit sich selbst immer tief gleich

(X) Richtig – Der Destruktor von Stapelobjekten wird implizit aufgerufen.
Grund: beim Aussprung aus dem Block (ohne delete), in dem es (ohne new) erzeugt wurde.

(X) Richtig – Für Schablonenparameter und für Ausnahmen können dieselben Typen benutzt werden.
Grund: nämlich alle

(X) Falsch – Mit dynamic_cast wird der Inhalt eines Oberklassenobjekts in ein Unterklassenobjekt übertragen.
Grund: Nein, das ist verboten (außer wenn explizit programmiert). Mit dynamic_cast wird ein Zeigerwert übertragen.

Aufgabe 6.

// CLeitung.hpp 
#ifndef CLEITUNG_HPP
#define CLEITUNG_HPP
class CLeitung { public: 
   void verbindungHerstellen();
   void verbindungFreigeben();
   bool belegt(); 
private:
   TLeitung leitung; };
#endif

// CLeitung.cpp
void CLeitung::verbindungHerstellen() { ::verbindungHerstellen(leitung);} ;
void CLeitung::verbindungFreigeben() { ::verbindungFreigeben(leitung);} ;
bool CLeitung::belegt() { return ::belegt(leitung);} ;