#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 Multiplikation & ausdruck) {
cout << ausdruck.ergebnis() << endl;
}
int main() {
Addition a(2,3);
Multiplikation m(2,3);
anzeigen(a);
anzeigen(m);
return 0;
}

eine Inklusionspolymorphie setzten und bei mir bringt dev-c++ immer den selben Fehler (return-statement with a value, in function returning 'void') in Zeile 12
Programm sieht bei mir dann so aus:

#include <cstdlib>
#include <iostream>

using namespace std;

class Multiplikation
{
public:
virtual void ergebnis() const
{
// cout << "Exemplar von Multiplikation" << endl;
return op1_ * op2_;
}
Multiplikation(const double& op1,const double& op2):op1_(op1),op2_(op2) {
}

protected:
double op1_,op2_;
};
class Addition:public Multiplikation {
public:
Addition(const double& op1,const double& op2):op1_(op1),op2_(op2) {
}
void ergebnis() const
{
cout << "Exemplar von Addition" << endl;
}
{
return op1_ + op2_;
}
protected:
double op1_,op2_;
};
void test(const Multipliaktion&v)
{
v.ergebnis();
};
//void anzeigen(const Multiplikation & ausdruck) {
//cout << ausdruck.ergebnis() << endl;
//}
//void anzeigen(const Addition & ausdruck){
//cout << ausdruck.ergebnis() << endl;
//}
int main()
{
Addition a(2,3);
Multiplikation m(2,3);
anzeigen(a);
anzeigen(m);

system("PAUSE");
return EXIT_SUCCESS;
}

Der Rückgabetyp von ergebnis ist void. Somit kann hier bei return (hier nicht nötig) auch nichts zurückgegeben werden.
Bitte benutzte Code-Tags und Einrückungen.

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

aber ich kann ja nicht einfach return durch void ersetzen!

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

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.

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.