locked
AntMe und C++

    Frage

  • Hi

    Ich hab mich mal dran gesetzt, die C#-Vorlage für C++ umzuschreiben. Nur leider hab ich nicht soo die Ahnung von .Net...
    Das Problem ist, dass meine Ableitung von Ameise angeblich noch abstrakte Funktionen enthält und damit beim laden der Ameisen im Prog. eine Exception geworfen wird - das Schlüsselwort abstract taucht aber in meinem Code nicht auf. Hat jemand eine Idee, was die Ursache sein könnte? (mit virtual und override hab ich viel rumprobiert, das ist eine der Varianten, die sich kompilieren lassen)

    Der Code dazu:


    #pragma once

    using namespace System;
    using namespace System::Collections::Generic;
    using namespace System::Text;
    using namespace AntMe;

    namespace AntMe {
    namespace Spieler {
    namespace Grek40 {

        [Spieler(
            Name = "ChuckyTeam",
            Vorname = "",
            Nachname = ""
        )]

        [Typ(
            Name = "",
            GeschwindigkeitModifikator = 0,
            DrehgeschwindigkeitModifikator = 0,
            EnergieModifikator = 0,
            LastModifikator = 0,
            ReichweiteModifikator = 0,
            SichtweiteModifikator = 0
        )]

        public ref class MeineAmeise1 : public Ameise {
        public:
            MeineAmeise1(AntMe::Volk^ volk, int typIndex)
                : Ameise(volk, typIndex) {
            }

        static String^ BestimmeTyp(Dictionary<String^, int>^ anzahl) {
                return "";
            }

        virtual void Wartet() override {
            }

        void Sieht(Zucker zucker) {
            }

        void Sieht(Obst obst) {
            }

        void Sieht(Käfer käfer) {
            }

        void Sieht(Markierung markierung) {
            }

        void GreiftAn(Käfer käfer) {
            }

        void ZielErreicht(Zucker zucker) {
            }

        void ZielErreicht(Obst obst) {
            }

        virtual void IstUnterwegs() override {
            }

        virtual void IstMüde() override {
            }

        };
    } // namespace Grek40
    } // namespace Spieler
    } // namespace AntMe
    Mittwoch, 8. November 2006 22:09

Antworten

  • Hi Grek,

    cooler Ansatz! Das zeigt mal wieder wie cool das bei .NET funktioniert einzelne Klassen einfach mal in einer anderen Sprache zu schreiben
    Im übrigen sieht dein Code schon recht brauchbar aus.

    Was die "abstract"-Geschichte angeht:
    Nicht DEINE Klasse enthält die abstrakten Methoden sondern die Klasse von der du geerbt hast. Die Ur-Ameisen-Klasse hat eine ganze Reihe von abstrakten Methoden die in der Ursprungsklasse garnichts tun. Man markiert Methoden in Klassen als abstrakt wenn man den Programmierer, der von dieser Klasse ableitet dazu zwingen will diese Methoden selbst zu implementieren. Das ist das was du mit override gemacht hast.

    override "überschreibt" die vorhandenen Methoden der Ursprungsklasse und gibt dieser Methode dann eine neue Funktionalität.

    Um also eine funktionierende Ameisen-KI zu erzeugen musst du von der Urameise ableiten, die richtigen Attribute einfügen und dann per override alle abstrakten Methoden der Urklasse überschreiben. All das hast du schon gemacht und kannst jetzt anfangen deine KI zu bauen.

    Gute Arbeit soweit!

    beste Grüße
    vom Tom
    Donnerstag, 9. November 2006 09:36

Alle Antworten

  • Hi Grek,

    cooler Ansatz! Das zeigt mal wieder wie cool das bei .NET funktioniert einzelne Klassen einfach mal in einer anderen Sprache zu schreiben
    Im übrigen sieht dein Code schon recht brauchbar aus.

    Was die "abstract"-Geschichte angeht:
    Nicht DEINE Klasse enthält die abstrakten Methoden sondern die Klasse von der du geerbt hast. Die Ur-Ameisen-Klasse hat eine ganze Reihe von abstrakten Methoden die in der Ursprungsklasse garnichts tun. Man markiert Methoden in Klassen als abstrakt wenn man den Programmierer, der von dieser Klasse ableitet dazu zwingen will diese Methoden selbst zu implementieren. Das ist das was du mit override gemacht hast.

    override "überschreibt" die vorhandenen Methoden der Ursprungsklasse und gibt dieser Methode dann eine neue Funktionalität.

    Um also eine funktionierende Ameisen-KI zu erzeugen musst du von der Urameise ableiten, die richtigen Attribute einfügen und dann per override alle abstrakten Methoden der Urklasse überschreiben. All das hast du schon gemacht und kannst jetzt anfangen deine KI zu bauen.

    Gute Arbeit soweit!

    beste Grüße
    vom Tom
    Donnerstag, 9. November 2006 09:36
  • kleiner Nachtrag:

    warum hast du die Methoden "IstUnterwegs", "IstMüde" und "Wartet" als virtuell markiert? Methoden die als "virtual" markiert sind erlauben es, dass diese Methode bei abgeleiteten Klassen wieder überschrieben werden dürfen, haben also keinen Einfluss auf die Methode in deiner abgeleiteten Klasse.

    Tschö
    Tom
    Donnerstag, 9. November 2006 09:50
  • Also Ich hab das Problem jetzt gefunden... Ich hatte alle Methoden die Parameter hatten noch nicht überschrieben und deswegen selbst wieder eine abstrakte Klasse erzeugt. Der Hauptfehler lag im folgenden (bei allen derartigen Definitionen) :

        void Sieht(Zucker zucker)  {
            }

    im Gegensatz zu der neuen Version, die geht:

        virtual void Sieht(Zucker^ zucker) override {
            }

    Das virtual muss bei der Verwendung von override explizit angegeben werden.
    Um also eine komplett lauffähige Vorlage zu erhalten muss im Anfangscode einfach nur jede Methode die noch nicht virtual override ist angepasst werden.

    Falls ihr Interesse habt könnt ihr die Vorlage auch noch bisschen nachbearbeiten und mit auf eure Seite stellen ;) (Im Projekt müssen Verweise hinzugefügt werden,...)
    Donnerstag, 9. November 2006 15:45
  • Hallo,

    Du brauchst bei allen Typen ein ^ am Ende, da ja alles managed ist.
    Also Käfer^. Obst^ ...

    elli
    Montag, 13. November 2006 22:21