3. inklusionspolymorphie

inklusionspolymorphie

  • ?

    hallo vielleicht kann mir ja jemand von euch helfen. ich muß in dieses kleine programm:

    #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;
    }

    0
  • B

    Hallo,

    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.

    0
  • ?

    also muß ich alle returns durch void ersetzten wenn ich das richtig verstehe.

    0
  • C

    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());
...
    0
  • ?

    aber ich kann ja nicht einfach return durch void ersetzen! 😞

    0
  • C

    ekundu schrieb:

    aber ich kann ja nicht einfach return durch void ersetzen! 😞

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

    0
  • ?

    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.

    0
  • C

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

    0
  • ?

    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

    0
  • C

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

    0
  • ?

    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

    0
  • ?

    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.

    0
  • D

    Verwende endlich Code-Tags!

    0
  • ?

    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.

    0
Anmelden zum Antworten