HILFE!!



  • hey liebe community, ich habe derzeitein problem mit einer programmieraufgabe:

    der OBJEKTORIENTIERTE Zoo
    -------------------------
    z:\oop\animals\zoo.dpr; animals.h, animals.cpp
    Vorlage: basics\prj1

    1. Basisklasse TAnimal folgenden Inhalts:
    versteckt:
    nr als static wie vorgegeben
    stomage als Mageninhalt (float)
    maxstomage (float) = maximum

    so versteckt, dass abgeleitete Klasse es sieht:
    move(distance) - gibt Spruch aus, dass Animal nr sich um distance "bewegt" hat

    öffentlich:
    stomage anzeigen, restvolumen anzeigen (wieviel geht noch rein)
    funktion eat(float) -> stomage erhöhen, aber nur bis maxstomage
    -- Spruch ausgeben, wieviele angeboten und wieviel davon gefressen wurde von animal nr
    default-Konstruktor, der stomage auf 0
    und maxstomage auf irgendwas positives setzt
    weiterer Konstruktor mit 2 Parametern für stomage und maxstomage
    funktion go(distance) -> move(restdistance) aufrufen, pro strecke stomage verringern,
    wenn magen leer -> verweigerung weiterer bewegung
    (Art der Bewegung ausgeben (TAnimal: "irgendwie"),
    geforderte + zurückgelegte Strecke ausgeben)
    Stomage verringert sich je nach Strecke

    2. im Hauptprogramm paar TAnimal erzeugen, füttern, bewegen lassen,
    sterben lassen.

    3. zwei Klassen ableiten: TBird und TFish
    bei beiden move() überschreiben mit anderem Spruch ("geflogen", "geschwommen")
    im Hauptprogramm je ein Objekt dieses Typs erzeugen, füttern, bewegen lassen,
    sterben lassen (Fish: statisch, Bird: dynamisch)

    3. 5 Animals/Birds/Fishes in einem Array ablegen mit beliebigen
    Voreinstellungen für (max)stomage, in for-schleifen alle durchfüttern
    bzw. bewegen, am Ende } gehen sie alle drauf.

    kann mir bitte jemand helfen?? 😞



  • eNtRyXxX schrieb:

    hey liebe community, ich habe derzeitein problem mit einer programmieraufgabe:

    Beschreibe doch mal dein problem. was hast du denn schon?



  • kann mir bitte jemand helfen??

    Zeige deinen bisherigen Ansatz bzw. die von dir erstellten Klassen.
    Das ist nicht allzu schwer. Da in C++: http://www.cpp-tutor.de/cpp/le09/klassen.html



  • eNtRyXxX schrieb:

    kann mir bitte jemand helfen?? 😞

    Sicher, wenn du sagst was dein Problem ist...
    Wir wissen nicht mal, in welcher Sprache das umgesetzt werden soll.



  • Unit1.cpp
    //---------------------------------------------------------------------------
    #include <iostream.h> //für cin, cout
    #include <conio.h> //für getch
    #pragma hdrstop
    #include "EineKlasse.h"
    //---------------------------------------------------------------------------

    #pragma argsused
    int main(int argc, char* argv[])
    {
    cout << "OOP RULEZZZ sagt die XTA81" << endl; // endl = newline
    //cout << "Next free Number: " << EineKlasse::Counter() << endl; //versteckt //<<<12.11.<<<<<<<
    cout << "Next free Number: " << EineKlasse::getCounter() << endl; //public //<<<12.11.<<<<<<<
    { //Gültigkeitsbereich
    //statische Objekte
    EineKlasse t1; // ruft Default-Konstruktor auf

    EineKlasse t2(5); // ruft EineKlasse::EineKlasse(int) auf
    t1.eineFunktion(1); // ruft Memberfunktion für die Instanz t1 auf
    t2.eineFunktion(7); // ruft Memberfunktion für die Instanz t2 auf
    EineKlasse t3(t2); // ruft copy-Konstruktor auf: t3 := t2
    t3.eineFunktion(7);

    } //t1, t2, t3 wird zerstört
    cout << "Next free Number: " << EineKlasse::getCounter() << endl; //<<<<<<<<<<<<12.11.<<<<<<<<
    //jetzt das dynamische duo --> Speicher nur belegen, wenn notwendig (HEAP)
    {
    EineKlasse *zeiger = new EineKlasse(3); // Instanz auf dem Heap erzeugen
    zeiger->eineFunktion(2); // Memberfunktion aufrufen
    delete zeiger; // Speicher freigeben, der auf der Adresse in zeiger beginnt
    zeiger = NULL;

    EineKlasse *zeiger2 = new EineKlasse(4); // Instanz auf dem Heap erzeugen
    zeiger2->eineFunktion(3); // Memberfunktion aufrufen
    //ein heldenhafter test
    //cout << zeiger->id() << endl; //error privat
    //cout << zeiger->id() << endl; //error privat //<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    if (zeiger) // if zeiger <> nil
    cout << zeiger->getId() << endl; //error: Zugriff auf freigegebenen Bereich

    //delete zeiger2 fehlt
    } //zeiger und zeiger2 nicht mehr zugänglich
    //delete zeiger2; //hier undefiniert

    EineKlasse t1(7); //<<<<<<<<<<<<<<<<<<19.11.------------------
    cout << "\nNeues Ergebnis: " << t1.NeueFunktion(5) << endl; //<<<<<<<<<<<<<<<<<<19.11.------------------

    {
    cout << "\n\nNeue Klasse:\n";
    NeueKlasse t2; //geerbter Standardconstructor verwendet, id wird verwendet
    t2.eineFunktion(5); //<<-----------------19.11------geerbte Version wird nicht mehr verwendet, weil überschrieben

    cout << "\n\nTest Polymorphismus\n";
    /*
    die "eineFunktion" darf nicht statisch compiliert, sondern erst zur Laufzeit
    entschieden werden, welche Version die richtige ist: die Methode muss
    " - virtual - " sein !!!!!!!!!!!!!!!!!!!
    */
    t1.eineFunktion(5);
    t1.NeueFunktion(5);
    t2.eineFunktion(3);
    t2.NeueFunktion(3);

    cout << "\nTypwandlungen:\n";
    EineKlasse t3 = (EineKlasse)t2;
    EineKlasse t4 = t2;
    //NeueKlasse t5 = t1; //nicht möglich

    cout << "\t2: "; t2.eineFunktion(2);
    cout << "\t3: "; t3.eineFunktion(3);
    cout << "\t4: "; t4.eineFunktion(4);

    } //t4, t3, und t2 werden zerstört weil lokal

    cout << "\nArray: \n";
    NeueKlasse* K[5];
    K[0] = new NeueKlasse;
    K[1] = new NeueKlasse;
    K[0]->a = 100; //ok, weil public
    cout << K[0]->a + K[1]->b << endl;
    //K[2]->eineFunktion(2); //???error, wenn vorher kein new !

    cout << "\n\nEnde." << endl; // "\n" ist eine newline, wie endl
    getch(); //warte auf Tastendruck
    return 0;
    }
    //---------------------------------------------------------------------------



  • //---------------------------------------------------------------------------
    #include <iostream.h> //für cin, cout
    #pragma hdrstop
    #include "EineKlasse.h"
    //---------------------------------------------------------------------------
    #pragma package(smart_init)

    //IMPLEMENTATION --> Innenleben der Funktionen

    EineKlasse::EineKlasse() // der Default-Konstruktor
    : m_eineVariable(0) //Anfangswert für Variable konstant
    {
    id = Counter++; cout << id << ": "; //<<<<<<12.11.<<<<<<<<<<<<
    cout << "Default Constructor\n";
    }

    EineKlasse::EineKlasse(int a) // weiterer Konstruktor mit Parameter
    : m_eineVariable(a) //Anfangswert für Variable aus Parameter
    {
    id = Counter++; cout << id << ": "; //<<<<<<12.11.<<<<<<<<<<
    cout << "Constructor with Parameter " << a << "\n";
    }

    EineKlasse::EineKlasse(const EineKlasse& a) // Copy-Konstruktor
    : m_eineVariable(a.m_eineVariable) //Anfangswert für Variable aus Objekt a
    {
    id = Counter++; cout << id << ": "; //<<<<<<<12.11.<<<<<<<<<<<<
    cout << "Copy Constructor with Parameter " << a.m_eineVariable << "\n";
    }

    EineKlasse::~EineKlasse() // der Destruktor
    {
    cout << "Instance " << id << " is destroyed.\n"; //<<<<<<<<<<<<12.11.<<<<<<<<<<<<
    }

    // Member-Funktion
    int EineKlasse::eineFunktion(int a) //<<----------------------------------
    {
    int ergebnis = m_eineVariable * a;
    std::cout << "Ergebnis EineKlasse= " << ergebnis << std::endl;
    return ergebnis;
    }

    //<<<<<<<<<<<<<<<<<<12.11.
    int EineKlasse::Counter = 0; // Anfangswert für static-Variable

    int EineKlasse::getCounter() // öffentliche Zugriffsfunktion
    {
    return Counter;
    }

    int EineKlasse::getId() // öffentliche Zugriffsfunktion
    {
    return id;
    }

    int EineKlasse::NeueFunktion(int x) //<<<<<<<<<<<<<<19.11. <------------------
    {
    cout << "NeueFunktion: ";
    int a = eineFunktion(x) + 1; //Aufruf einer anderen Methode
    return a;
    }

    //----------------------------------------------------------------------------
    //NEUE Klasse-----------------------------------------------------------------
    // Member-Funktion
    int NeueKlasse::eineFunktion(int a) //<<--19.11.------------------------
    {
    int ergebnis = m_eineVariable - a; //
    std::cout << "Ergebnis NeueKlasse= " << ergebnis << std::endl;
    return ergebnis;
    }



  • also aus diesem "ansatz" soll die aufgabe abgleitet werden und damit hab ich arge probleme^^



  • Ist das Code von deinem Dozenten? 😮

    BTW: Es heißt stomach und nicht stomage.



  • ja ist von ihm...-.-
    hast du ne ahnung?



  • zeig mal was von dir. 😃
    ... oder lies zumindest dies vorher durch: http://www.cpp-tutor.de/cpp/le09/klassen.html
    Außerdem gibt es hier code tags! 😉



  • So eine Frage in dieser Forum ist letztlich eine Frechheit.

    Einfach mal den Code hinrotzen, die Leser sollen sich dann was daraus bilden. Vermutlich surft er gerade in Facebook, während ihm jemand seine Aufgabe lösen soll.

    Ich nenne sowas Respektlosigkeit, nicht mal die Frage sauber UND LESBAR zu formulieren.


Log in to reply