?
Sorry hier noch mal mit code tags.
Aufgabe 1
Gegeben sind die beiden folgenden Klassen Addition und Multiplikation sowie die
Funktionen main() und anzeigen(), letztere in einer unvollständigen Fassung.
#include <iostream>
using namespace std;
class Multiplikation {
public:
Multiplikation(const double& op1,const double& op2):op1_(op1),op2_(op2) {
}
double ergebnis() const {
return op1_ * op2_;
}
protected:
double op1_,op2_;
};
class Addition {
public:
Addition(const double& op1,const double& op2):op1_(op1),op2_(op2) {
}
double ergebnis() const {
return op1_ + op2_;
}
protected:
double op1_,op2_;
};
void anzeigen(const Multipliaktion & ausdruck) {
cout << ausdruck.ergebnis() << endl;
}
int main() {
Addition a(2,3);
Multiplikation m(2,3);
anzeigen(a);
anzeigen(m);
return 0;
}
Schreiben Sie nun fünf Programmversionen, die jeweils
· parametrische Polymorphie,
· Inklusionspolymorphie,
· Überladungspolymorphie und
· Typumwandlungspolymorphie mit einem entsprechenden
· Typumwandlungsoperator und einem
· Typumwandlungskonstruktor
zur Implementierung verwenden. Nehmen Sie alle notwendigen Änderungen im Programm selbst vor, also etwa das Einführen einer Basisklasse oder das Einführen neuer Methoden.
Aufgabe 2
Gegeben ist das folgende Programmfragment:
#include <iostream>
#include <cassert>
using namespace std;
class Menge {
public:
Menge():elemente_(0) {
}
Menge(unsigned short int element):elemente_(0) {
assert(element < sizeof(elemente_) * 8);
elemente_ = 1 << element;
}
Menge(const Menge& m):elemente_(m.elemente_) {
}
Menge vereinigt(const Menge& m) const {
return neueMenge(elemente_ | m.elemente_);
}
Menge geschnitten(const Menge& m) const {
return neueMenge(elemente_ & m.elemente_);
}
Menge komplement() const {
return neueMenge(~elemente_);
}
Menge& elementHinzufuegen(unsigned short int element) {
assert(element < sizeof(elemente_) * 8);
elemente_ |= 1 << element;
return *this;
}
unsigned short int maechtigkeit() const {
unsigned short int m = 0,
bits = sizeof(elemente_) * 8;
for (unsigned short i = 0; i < bits; ++i)
if (elemente_ & 1 << i)
++m;
return m;
}
void ausgeben(ostream& os) const {
unsigned short int m = 0,
bits = sizeof(elemente_) * 8;
os << "{ ";
for (unsigned short i = 0; i < bits; ++i)
if (elemente_ & (1 << i))
os << i << ' ';
os << "}";
}
void einlesen(istream& is) {
elemente_ = 0;
unsigned short int element;
char c;
do {
is >> c;
} while (c != '{');
do {
do {
is >> c;
} while (c == ' ');
if (c != ' ' && c != '}')
is.putback(c);
if (c != '}') {
is >> element;
assert(element < sizeof(elemente_) * 8);
elemente_ |= 1 << element;
}
} while (c != '}');
}
// Hier Operatoren fuer Komplement und Maechtigkeit ergaenzen
private:
unsigned long elemente_;
static Menge neueMenge(unsigned long elemente) {
Menge m;
m.elemente_ = elemente;
return m;
}
};
ostream& operator<<(ostream& os,const Menge& m) {
ostream::sentry vorUndNacharbeiten(os);
if (vorUndNacharbeiten)
m.ausgeben(os);
return os;
}
istream& operator>>(istream& is,Menge& m) {
istream::sentry vorUndNacharbeiten(is);
if (vorUndNacharbeiten)
m.einlesen(is);
return is;
}
Menge& operator,(Menge& m1,unsigned short element) {
return m1.elementHinzufuegen(element);
}
// Hier Operatoren fuer Vereinigung und Schnitt ergaenzen
int main() {
Menge m1, m2, m3;
m1 = 1, 5, 19; // Elemente 1, 5 und 19 hinzufuegen
cout << "m1 = " << m1 << endl;
m2 = 30, 15, 19; // elemente 15, 19 und 30 hinzufuegen
cout << "m2 = " << m2 << endl;
m3 = m1 | m2; // Vereinigung von m1 und m2
cout << "m3 = " << m3 << endl;
cout << !m3 << endl; // Maechtigkeit von m3; ok, kein optimaler Operator
m3 = ~m3; // Komplementaermenge
cout << "Komplement von m3 = " << m3 << endl;
cout << "Maechtigkeit von m3 = " << !m3 << endl; // Maechtigkeit von m3
m3 = m3 & ( m1 | ~m2); // Schnittm. von m3 und (m1 vereinigt Kompl. von m2)
cout << "Schnittmenge von m3 und (m1 vereinigt komplement von m2) = "
<< m3 << endl;
cout << "Maechtigkeit von m3 = " << !m3 << endl; // Maechtigkeit von m3
cin >> m3;
cout << "m3 = " << m3 << endl;
cout << "Maechtigkeit von m3 = " << !m3 << endl;
return 0;
}
Implementieren Sie die Operatoren zur Ermittlung der Mächtigkeit (!) und zur Komplementbildung(~) als Memberfunktionen an der dafür vorgesehenen Stelle.
Implentieren Sie die Operatoren für Schnitt (&) und zur Vereinigung (|) von Mengen als freie Funktionen an den dafür vorgesehenen Stellen
Wenn Sie das Programm übersetzen und ausführen, erhalten Sie bei Eingabe der Menge {0 31} den folgenden Ein- und Ausgaben:
m1 = { 1 5 19 }
m2 = { 15 19 30 }
m3 = { 1 5 15 19 30 }
5
Komplement von m3 = { 0 2 3 4 6 7 8 9 10 11 12 13 14 16 17 18 20 21 22 23 24 25
26 27 28 29 31 }
Maechtiegkeit von m3 = 27
Schnittmenge von m3 und (m1 vereinigt komplement von m2) = { 0 2 3 4 6 7 8 9 10
11 12 13 14 16 17 18 20 21 22 23 24 25 26 27 28 29 31 }
Maechtigkeit von m3 = 27
{0 31}
m3 = { 0 31 }
Maechtigkeit von m3 = 2
Tipp: Trennen Sie bei der Eingabe einer Menge die Elemente nicht durch Komma! Ansonsten "hängt" das Programm oder stürzt ab.
