inklusionspolymorphie

[CStoll]

Wieso baust du deine "Ergebnis()"-Methoden überhaupt um? Es passt doch besser zu ihrem Namen, wenn sie das Rechenergebnis als Rückgabewert ausspuckt (und außerdem kannst du so auch mehrere Operatoren verschachteln:

Multiplikation m(1,2);
Addition a(3,m.ergebnis());
...

[ekundu]

aber ich kann ja nicht einfach return durch void ersetzen!

[CStoll]

ekundu schrieb:

aber ich kann ja nicht einfach return durch void ersetzen!

Wie schon gesagt: WARUM willst du das überhaupt machen?

[ekundu]

ich weiß das es am anfang ganz gut aussah aber das ist einfach mal eine ganz schön bescheuerte aufgabe sollen halt verschiedene varrianten zur inklusion benutzen.

[CStoll]

Häh? Kannst du das mal erklären? Was willst du erreichen?

[ekundu]

sorry konnte mich nicht so schnell berichtigen ich meine implementierung.
wir hatten einen quelltext vorgegeben ganz simpel eigentlich und sollten dann verschiedene Programmversionen schreiben(5 an der Zahl) die verschiedene Polymorphismen zur Implementierung benutzen.
jetzt klar

[CStoll]

Und jetzt kommt die Millionenfrage: Was haben deine obigen Programmschnipsel mit "Polymorphie" zu tun?

[ekundu]

ja ich weiß sieht nicht professionell aus aber habe grade erst angefangen ich kann dir ja mal die komplette aufgabe posten damit du die ausgangssituatuin kennst

[ekundu]

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 bitte ergänzen… & ausdruck) {
cout << ausdruck.ergebnis() << endl;
}
int main() {
Addition a(2,3);

- 2 -

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;

- 3 -

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
- 4 -
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.

[dEUs]

Verwende endlich Code-Tags!

[ekundu]

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.