Kleines Text rpg und schon erste schwierigkeiten



  • Warum setzt du nicht einen Haltepunkt und schaltest die Prozeduren einzeln durch. So musst du doch sehen wo das Programm hinspringt.



  • Deine Variablen Menue und Menuu werden nirgends Initialisiert.
    Demnach werden nach dem ersten, die beiden folgenden switch anweisungen
    übersprungen.

    Danach steht ohne eine weitere Abfrage der Satz den du nicht sehen willst.
    "Wie ist euer Name usw ..."

    Aber ganz generell mal auch wenn / bzw. grade weil du es zum üben machst.

    Schreib so ein Spiel am besten mit Klassen auch wenn es dir vielleicht
    am Anfagn schwer fällt. Weil mit einem Spiel in einer riesigen main
    funktion wirst du nicht glücklich.

    Lieber kleine langsame fortschritte als einfach mal drauf los
    und dann so ein Chaos wie in deinem Code.



  • Also dass mit den Klassen ist wirklich schwer. Mal kapier ich das, dann steig ich da wieder nicht durch^^

    Ich wollte es zuerst so machen:

    class Held
    {
    int Staerke;
    int Geschicklichkeit;
    int Mana;
    int Lebenspunkte;
    usw.
    }

    class Schaf
    {
    int Staerke;
    usw.
    }

    das erschien mir aber unvorteilhaft, denn wenn ich für jedes noch so kleine Monster eine Klasse erstelle, wird das unglaubliche ausmaße annehmen.
    Außerdem weiß ich nicht, wie das Kampfsystem funktioniren soll, wie ich die Lernpunkte beschränken kann, heißt, wenn ich 10 Lernpunkte habe, dass ich auch nur 10 Lernpunkte und nicht unendlich ausgeben kann.
    Dass die Stärke den Angriff erhöht, und dann bin ich ja noch ganz am Anfang^^

    Ich meine, ich brauch auch ein bestimmtest Feld, wo man rumlaufen kann.
    Also, nach Norden, nach Süden, nach Osten, nach Westen. Natürlich nicht visuell. Dann soll auch mal eine Nachricht kommen, wie z.B.

    "Eine riesige Klippe verspeert dir den Weg. Noch ein Schritt weiter und du stürzt ins Meer."

    Was mich brennend interessieren würde, wie ich das Spiel speichern und auch wieder laden kann. Ich weiß, es ist sehr viel, was ich wissen möchte, ich möchte es auch lernen. Ich finde nur kein gescheites Tutorial. ich habe zwar ein Buch, aber damit kann ich jetzt auch nichtmehr weiter.

    Grüße



  • Naja. Sagt dir Vererbung etwas?

    Ein wenig musst du dir auch selber Gedanken machen, wie etwas funktionieren soll. 😉
    Sonst macht es ja keinen Spass, wenn alles bereits vorgegeben ist.

    Speicher kannst du ja ganz einfach mittels Files. Wenn dir if/ofstreams etwas sagen.

    Zum Beispiel hier:
    http://www.cplusplus.com/reference/iostream/ofstream/

    Ansonsten einfach ein wenig googlen zu den Stichworten.



  • class Held 
    { 
    int Staerke; 
    int Geschicklichkeit; 
    int Mana; 
    int Lebenspunkte; 
    } 
    
    //ist doch ganz gut so...
    
    class Schaf 
    { 
    int Staerke; 
    //bla
    }
    

    was spricht dagegen?

    denn wenn ich für jedes noch so kleine Monster eine Klasse erstelle

    oder du würdest was ganz verrücktes machen:

    struct Tdmg
     {
    };
    
    struct Truestung
     {
    };
    
    struct Tspell
     {
    size_t manacost;
    size_t cooldown
    };
    
    struct bar
     {
      size_t insg;
      size_t act;
      bar (size_t _insg) : insg (_insg) {};
      delta_minus (size_t value)
       {
        if (value > act)
          act = 0;
        else act -= value;
       }
      delta_plus (size_t value)
       {
        act += value;
        if (act > insg)
          act = insg;
       }
     };
    
    class creep
    {
     private:
      unsigned char lvl; //bis lvl 255 reicht doch? damit machste so gar die wow-ler platt ;D
     public: //var
      static size_t ruestung_per_lvl;
      static size_t hp_per_lvl;
      static size_t mana_per_lvl;
      bar ruestung;
      bar hp;
      bar mana;
      const Truestung ruestung_art;
     public: //fkt
      creep (unsigned char _lvl, const Truestung &_ruestung)
        : ruestung (ruestung_per_lvl * lvl), hp (hp_per_lvl * lvl), mana (mana_per_lvl * lvl), ruestung_art (_ruestung)
        {};
      unsigned char GetLvl (void) const {return lvl;};
      void GetHit (size_t dmg, const Tdmg &schadensart)
       {
        ;
       }
    };
    

    Wenn du ganz viel Lust hast, dann kannste auch noch verschiedene creep-fähigkeiten erstellen - und das halt iwie mit in die klasse packen...
    was auch noch komplett fehlt sind halt die beiden leeren klassen ganz oben - dachte mir halt, dass man dort die beziehung zwischen dmgart und rüstungsart iwie realisieren kann... Tspell is halt auch nur angedeutet und überhaupt ^^

    also dann - vll kommt dir ja jz ne idee, wie man das alles besser machen könnte?

    bb, Tom



  • Tag'chen,
    Ähm ich an deiner Stelle würde auch besser Vererbung verwenden, wenn du wirklich nicht hast dein Leben damit zu vollbringen Monster Klassen zu basteln 😉

    Wenn du also weißt, dass alle Creeps auch die Attribute:
    - Staerke
    - Intelligenz
    - Agilitaet
    - Willesnkarft
    - ...
    - Healthpoints
    - Manapoints
    - BaseMeeleDam
    - BaseRangeDam
    - BaseSpellDam
    - Level
    - ... was dir noch so einfällt 😉

    besitzen sollen, dann leg dir doch einfach eine Basisklasse an:

    class CCreep {
    
        private:
    
            // creep properties ( s.o. )
    
        public:
    
            // Methods
    };
    

    So könntest du via' Vererbung diese Eigenschaften für Creeps übernehmen und für spezielle Bosmonster erweitern.

    Gruß Tobi.



  • T0bi schrieb:

    So könntest du via' Vererbung diese Eigenschaften für Creeps übernehmen und für spezielle Bosmonster erweitern.

    Oder du machst einfach ein Attribut für den Einheitentyp ( short ) und dann kannst du sehr viele Eigenschaften an einem separaten Ort (z.B. in einem struct ) speichern. Zum Beispiel maximale Lebenspunkte, Angriffsreichweite und sonstige konstante Werte müssen ja nicht für jede Instanz existieren. Dann musst du auch nicht für jeden Typen eine eigene Klasse basteln.

    Da kannst du auch einen Konstruktor machen mit dem Typen als Parameter, und die restlichen Werte berechnen sich dann daraus bzw. werden aus dem jeweiligen struct geholt (bei mehreren creepspezifische Strukturen z.B. in einem Array).



  • Hier sind schon soviele gute Kommentare gekommen, was man alles machen könnte. Das find ich super! Ich persönlich wäre auch für die Verwendung von Klassen mit Vererbung, wie bereits vorgeschlagen mit einer Basisklasse.

    Und damit es nicht gleich so kompliziert wird hier mal ein Beispiel:

    class Figure
    {
      private:
          int Health;
          int Strength;
          ...                // weitere Attribute von Figuren
      public:
          Figure();
          int gethealth();
          ...                // weitere Get-,Set- und andere Methoden
    };
    
    class Gremlin : public Figure
    {
       ...                   // eigene spezifische Attribute und Methoden 
    };
    

    und damit du nicht alles nochmal und nochmal schreiben musst,
    schreibe anstelle von Gremlin oder Monster1 einfach eigene Monstertyen.
    Vielleicht haben ja monster die untot sind von vorneherein irgendwelche
    besonderen Eigenschaften. z.B.: Koennten Baeren auch vom Typ (Monsterklasse)
    natuerlich sein.

    Ich glaube in deinem Falle ist dein Ideenreichtum noch mehr gefragt als die Umsetzung. Es gib so viel, dass man bei solchen Sachen beachten kann/soll/muss.



  • Nexus schrieb:

    T0bi schrieb:

    So könntest du via' Vererbung diese Eigenschaften für Creeps übernehmen und für spezielle Bosmonster erweitern.

    Oder du machst einfach ein Attribut für den Einheitentyp ( short ) und dann kannst du sehr viele Eigenschaften an einem separaten Ort (z.B. in einem struct ) speichern. Zum Beispiel maximale Lebenspunkte, Angriffsreichweite und sonstige konstante Werte müssen ja nicht für jede Instanz existieren. Dann musst du auch nicht für jeden Typen eine eigene Klasse basteln.

    Da kannst du auch einen Konstruktor machen mit dem Typen als Parameter, und die restlichen Werte berechnen sich dann daraus bzw. werden aus dem jeweiligen struct geholt (bei mehreren creepspezifische Strukturen z.B. in einem Array).

    Das wäre eine gte Idee, man könnte - wenn man Ahnung von hat - auch alles in einer DB speichern und dann die Creep Klasse initialisieren, bzw. man könnte die Daten in einer Externen .TXT Datei sichern und dann in der gewünschten Zeile die Daten auslesen, so kannst du deinen Speicher etwas schonen, nicht das wenn du Millionen von Creeptypen hast, der Speicher voll ist.

    Gruß Tobi.



  • T0bi schrieb:

    man könnte die Daten in einer Externen .TXT Datei sichern und dann in der gewünschten Zeile die Daten auslesen, so kannst du deinen Speicher etwas schonen, nicht das wenn du Millionen von Creeptypen hast, der Speicher voll ist.

    Sry, aber den Beitrag hier halte ich für fehl am Platz ^^ Er weiß noch nicht mal richtig was mit Klassen anzufangen und du gehst davon aus, dass es Millionen Creeptypen gibt bzw geben kann...

    Außerdem: Würd ich so was nicht in ne *.txt - Datei schreiben sondern binär in irgend ne Datei (oder halt DB) - wenn überhaupt. Eigentlich wird das Auslesen der Datei/DB bei fast allen "normalen" Projekten den Speichergewinn wieder minimieren... Und mal ehrlich - wie viel RAM hast du und wie groß ist deine Auslagerungsdatei? Mal angenommen, es sind insg. nur 4GB... Denkst du wirklich, dass du mit Creeptypen (selbst mit Millionen) alleine, auch nur 1% voll bekommst? Oo

    bb



  • unskilled schrieb:

    Sry, aber den Beitrag hier halte ich für fehl am Platz ^^ Er weiß noch nicht mal richtig was mit Klassen anzufangen und du gehst davon aus, dass es Millionen Creeptypen gibt bzw geben kann...

    Es ist trotzdem von Vorteil, wenn ihm gesagt wird, dass die vererbten Klassen nicht die beste Lösung bei diesem Problem ist. Klar kann es zur Übung sinnvoll sein, aber wenn man solche Projekte auch etwas grösser werden lässt und etwas ernsthafter bei der Sache ist, kann eine Datenbank schon behilflich sein.

    unskilled schrieb:

    Und mal ehrlich - wie viel RAM hast du und wie groß ist deine Auslagerungsdatei? Mal angenommen, es sind insg. nur 4GB... Denkst du wirklich, dass du mit Creeptypen (selbst mit Millionen) alleine, auch nur 1% voll bekommst? Oo

    Nehmen wir einmal an, es gibt für jeden Creeptypen neben etlichen int und float -Werten noch spezielle Attribute wie z.B. Grafikklassen und Soundsets etc. Wenn du das wirklich für jede Einheit kopieren willst, ist das sicher nicht gerade optimal für den RAM. Klar kann bei diesem Projekt noch nicht die Rede von so etwas sein, aber es ist trotzdem sauberer, man speichert die Werte nur einmal ab. Zentral verwaltete Werte kann man auch leichter verändern, und die Übersichtlichkeit wird gesteigert.

    Und überhaupt: Das Argument, man brauche heute wegen den leistungsfähigen Prozessoren nicht mehr stark auf Performance zu achten und Speicherplatz ist sowieso kein Problem mehr, kann man so ziemlich überall bringen. Trotzdem ist es gut, wenn man von Anfang an lernt, ressourcensparend zu programmieren. Man sieht ja z.B., dass neuere Computerspiele keineswegs schneller sind als alte, und das ist neben verbesserter Grafik etc. auch auf schlampigere und verschwenderische Programmierung zurückzuführen.



  • Ihr habt mich alle voll verwirrt xD
    Ich glaube, ich bin einfach noch nicht soweit. Wobei, wenn ich es nicht mache und mich reinhänge, komme ich auch nicht weiter.
    Aber mit den Klassen ist ja alles schön und gut, aber ich verstehe das mit public, privat und mit den Methoden nicht ganz.

    Also public bedeutet, dass der Anwender die Werte verändern kann?
    Privat bedeutet, dass nur eine interne Aufforderung die Werte ändern kann?
    Methoden sind... ähm damit kann man ja ka.^^
    Konstruktor weiß ich sowieso nicht. Obwohl ich mir das schon paarmal durchgelesen habe.

    Ich danke euch allen für die Hilfe. Sind bestimmt ganz tolle Sachen bei, aber ich verstehe fast nur Bahnhof 😉

    Ich habe mich bzw. meine C++ kenntnisse überschätzt. Ich sollte wohl erstmal damit anfangen, dass man durch die Welt laufen kann und auch auf Monster stößt.

    Kampfsystem, Rüstungen usw. sollen erst später dazu kommen. Damit ich wenigstens schonmal das Spiel ansich soweit fertig habe.
    Ich habe dafür ein halbes Jahr eingeplant. Aber ich denke, dass könnte schon länger werden.

    Quest möchte ich, wenn ich nun irgendwie die Klassen verstehe, auch schon einbauen.
    Wie z.B. Gehe zum Hof von "XXX YYY". Überbringe die Botschaft, dass blabla und soundso sich in der Kaserne melden sollen.

    Meint ihr, dass wäre realisierbar.

    Achja, ihr redet immer davon, dass der code so unendlich lang wird, wenn ich dass auf meine Art mache. Aber wenn ihr z.B.:

    class Monster
    {
    int Staerke
    usw.
    }
    macht, müsst ihr doch auch jedes Monster wieder einzeln ersellen.

    Ich meine, nicht jedes Monster hat die gleichen Werte...

    Achja, jemand hat hier in den Raum geworfen, dass die text datein in einer anderen Datei abzuspeichern sein.
    Das hört sich gut an. Würde den Code bestimmt überschaulicher machen.
    Kann mir jemand erklären, wie das gehen soll?

    Ich finde das echt super nett von euch, dass ihr einem anfänger so helft. Vielleicht, weil ihr selbst so schwierigkeiten hattet.
    Wenn ich das in 10 Jahren spo halbwegs kann, werde ich auch mein bestes geben, um "noobs" zu helfen 😉

    Grüße



  • Achja, ihr redet immer davon, dass der code so unendlich lang wird, wenn ich dass auf meine Art mache. Aber wenn ihr z.B.:

    class Monster
    {
    int Staerke
    usw.
    }
    

    macht, müsst ihr doch auch jedes Monster wieder einzeln ersellen.

    Naja... Man erstellt eine Instanz einer Klasse:

    Monstertyp Monster;
    

    Ich meine, nicht jedes Monster hat die gleichen Werte...

    Richtig, und hier kommt der Konstruktor ins Spiel.
    Wenn du eine Instanz einer Klasse erstellst, kannst du gleich die Attribute
    bestimmen, indem du einen überladenen Konstruktor aufrufst

    class Monstertyp
    {
      private:
         int health;
      public:
         Monster(int h); // Konstruktor
    };
    
    // Übergabe des Parameters h
    Monstertyp::Monster(int h)
    {
       health = h;
    }
    

    Achja, hier noch der Aufruf:

    // Erstellen eines Monsters mit 100 Lebenspunkten
      // Die Zahl legt somit den Wert fest
      Monstertyp Monster1(100);
    

    Bei solchen Themen könnt ich Stunden herumprobieren.

    Noch ein Tip:
    Lass dich von den Projektgrößen und dem Umfang nicht einschüchtern.
    Step-by-Step ist hier das Zauberwort, außerdem wächst man mit der Aufgabe.
    Also noch viel Spass!



  • hardtolearncplusplus schrieb:

    ...

    Du solltest dich wirklich erstmal um die Grundlagen kümmern. Einen Einstieg versuche ich mal zu geben:

    a) Klasse vs. Objekt
    Eine Klasse ist eine Schablone, ein Objekt die konkrete Ausprägung. Sprich eine Klasse Monster soll nur eine Schablone sein. Was haben deine Viecher...ähh Monster an Eigenschaften gemeinsam? So zum Beispiel wird jedes Monster wohl eine Bezeichnung und irgendwelche Kampfwerte haben (z.B. Stärke und Abwehr).

    Beispiel:

    class Monster
    {
      private:
        std::string name;
        int staerke;
        int abwehr;
      //...
    };
    

    Das bedeutet nicht das du jetzt separate Klassen für jedes Monster brauchst. Das "konkrete" Monster könnte beispielsweise ein Oger sein (name="oger", staerke=20, abwehr=10) oder eine Riesenschnecke (name="Riesenschnecke", staerke=10, abwehr=0). Dies alles sind aber Objekte, keine Klassen. Erst wenn du feststellst das du unterschiedliche Eigenschaften benötigst, brauchst du auch neue Klassen.

    Monster oger;
    Monster riesenschnecke;
    // Zwar sind beide Variablen (oger und riesenschnecke) Monster, können aber
    // unterschiedliche Werte haben.
    

    b) Methode
    Was eine Funktion ist, solltest du verstehen. Eine Methode ist eine Funktion einer Klasse. Der unterschied zu einer Funktion besteht darin, das eine Methode Zugriff auf alle Elemente der zugehörigen Klasse hat (Wenn es sich um eine statische Methode handelt: nur auf die statischen Member der Klasse).

    Da nicht-statische Methoden immer zu einem konkreten Objekt gehören (das man in der Methode auch über den this->Zeiger verwenden kann [ist nur nötig bei Namenskonflikten, wie ich es absichtlich im nachfolgenden Beispiel bei der Methode SetName zeige]).

    class Monster
    {
      private:
        std::string name;
        //...
    
      public:
        void SetName(std::string const & name)
        { // Der this-Zeiger verweist auf das entsprechende Objekt, dazu später mehr
          // Zuweisung des Parameter "name" zu der Membervariable "name"
          this->name = name;
        }
    
        std::string GetName() const
        { // this-Zeiger ist hier nicht nötig, da es hier keinen Konflikt
          // mit einer anderen Variable name gibt.
          return name;
        }
        //...
    };
    
    int main()
    {
      Monster oger;
      Monster riesenschnecke;
      oger.SetName("Oger");  // Setzen des Namens über eine Methode, dies betrifft
                             // aber nur "oger", nicht riesenschnecke
      riesenschnecke.SetName("Riesenschnecke");
      std::cout << oger.GetName() << std::endl
                << riesenschnecke.GetName() << std::endl;
      // ...
    }
    

    c) Konstruktor (& Destruktor)
    Es ist gang und gebe das man Variablen initialisiert. Zu nichts anderen ist der Konstruktor. Der Konstruktor wird am Anfang einmalig pro erstellten Objekt aufgerufen, und das Gegenstück, der Destruktor wird einmalig pro erstellten Objekt aufgerufen wenn es zerstört wird.

    int main()
    {
      Monster oger;              // Hier wird der Standardkonstruktor von der Klasse
                                 // Monster und dem Objekt oger aufgerufen.
      {
        Monster riesenschnecke;  // Hier wird der Standardkonstruktor von der Klasse
                                 // Monster und dem Objekt riesenschnecke aufgerufen.
      } // Hier wird riesenschnecke destruiert
    
    } // Hier wird oger destruiert
    

    Es kann mehr als einen Konstruktor geben (aber nur ein Destruktor, da es hier keine Aufrufparameter gibt). Als Standardkonstruktor wird ein Konstruktor bezeichnet der keine Parameter besitzt.

    class Monster
    {
      private:
        std::string name;
        int staerke;
        int abwehr;
    
      public:
        Monster()      // Standardkonstruktor, heißt wie Klasse
        : name(""),    // <- Initialiserungsliste
          staerke(0),
          abwehr(0)
        {
          // <- Konstruktorrumpf
        }
    
        Monster(   // Konstruktor mit Parametern
          std::string const & name,
          int staerke,
          int abwehr)
        : name(name),       // Zuweisung des 1. Parameters zur ersten Membervariable
          staerke(staerke),
          abwehr(name)
        {
        }
    
        ~Monster() // Destruktor in unseren Fall leer...
        {
        }
    };
    
    int main()
    {
      Monster oger("Oger", 20, 10);
      Monster riesenschnecke("Riesenschnecke", 10, 0);
    }
    

    Bedenke wieder das oger und riesenschnecke unterschiedliche Objekte sind. Jetzt hätten wir beide Objekte den oben genannten Vorgaben entsprechend angelegt.

    c.2) Konstruktor, Kopierkonstruktor, Zuweisungsoperator, Destruktor
    Noch ein Stück tiefergehend: Objekte kann man anlegen und zerstören, soweit so gut. Doch ebenso lassen sie sich zuweisen und kopieren.

    int main()
    {
      Monster oger("Oger", 20, 10); // Konstrukor
      Monster oger2(oger);          // Kopierkonstruktor
      Monster oger3 = oger;         // Achtung: Ebenso Kopierkonstruktor
      oger2 = oger;                 // Zuweisungsoperator
    } // <-- Destruktor(en)
    

    Automatisch legt der Compiler im Hintergrund auch alle davon an (sofern möglich), wobei der Standardkonstrukor nur generiert wird wenn kein anderer Konstruktor geschrieben wird. Und der automatische Kopierkonstruktor kopiert alle Werte 1:1 (Auchtung bei Zeigern, es wird der Wert des Zeigers, sprich die Adresse auf die er zeigt, und nicht das Objekt auf das er zeigt kopiert), der Zuweisungsoperator macht dies durch eine 1:1 Zuordnung.

    Wenn etwas davon nicht gewünscht ist, kann man die entsprechende Methode private deklarieren und verzichtet auf die Definition.

    Was der Kompiler automatisch generiert

    class Klassenname
    {
      public:
        Klassenname();                               // Konstruktor
        Klassenname(Klassenname const &);            // Kopierkonstruktor
        Klassenname& operator=(Klassenname const &); // Zuweisungsoperator
        ~Klassenname();                              // Destruktor
    }
    

    Mehr tippe ich aber erstmal nicht...

    cu André



  • hardtolearncplusplus schrieb:

    Aber mit den Klassen ist ja alles schön und gut, aber ich verstehe das mit public, privat und mit den Methoden nicht ganz.

    Also public bedeutet, dass der Anwender die Werte verändern kann?
    Privat bedeutet, dass nur eine interne Aufforderung die Werte ändern kann?

    Private Variablen und Funktionen der Klasse können im Normalfall nur intern aufgerufen bzw. bearbeitet werden, während öffentliche auch von ausserhalb manipulierbar sind. Beispielsweise ist es oft sinnvoll, die Membervariablen privat zu machen und dann über Get- und Set-Funktionen (Schnittstellen) diese zu manipulieren.

    class MeineKlasse
    {
       private: // privat: Variablen
          int x;
          float y;  // y wird z.B. nur intern benötigt, deshalb keine Schnittstellen für y
    
       public:  // öffentlich: Schnittstellen
          void SetX(int NewX);
          int GetX();
    };
    
    void MeineKlasse::SetX(int NewX)
    {
       x = NewX;
    }
    
    int MeineKlasse::GetX()
    {
       return x;
    }
    
    int main()
    {
       MeineKlasse A, B; // A und B sind Objekte oder Instanzen der Klasse
       A.x = 3;          // geht nicht, weil x privat ist. Genauso y...
       A.SetX(3);        // geht, weil die Funktion öffentlich (public) ist.
       int i = A.x;      // geht auch nicht
       int i = A.GetX(); // geht wieder
    }
    

    hardtolearncplusplus schrieb:

    Methoden sind... ähm damit kann man ja ka.^^

    Methoden nennt man die Funktionen, die im Zusammenhang mit Klassen bestimmte Aufgaben erfüllen. Meistens bezeichnet man damit Memberfunktionen, also die Funktionen, die in der Klasse deklariert sind. Im Beispiel vorher wären GetX() und SetX() Methoden.

    hardtolearncplusplus schrieb:

    Konstruktor weiß ich sowieso nicht. Obwohl ich mir das schon paarmal durchgelesen habe.

    Der Konstruktor ist diejenige Memberfunktion, die beim Erstellen einer Instanz aufgerufen wird. Eine Klasse kann mehrere Konstruktoren haben. Diese können beim Aufruf Parameter übernehmen, um die internen Variablen auf einen Startwert zu setzen. Konstruktoren ohne Parameter nennt man Standardkonstruktoren. Normalerweise wird ein Standardkonstruktor automatisch vom Compiler erstellt, sobald du jedoch irgendeinen eigenen Konstruktor definierst, nicht mehr.

    class MeineKlasse
    {
       private:
          int x;
          float y; 
       public:
          MeineKlasse(int NewX = 0);         // Konstruktor-Deklaration
          void SetX(int NewX);
          int GetX();
    };
    
    MeineKlasse::MeineKlasse(int NewX)   // Konstruktor-Definition
    {
       x = NewX;
       y = 0.f;
    }
    
    int main()
    {
       MeineKlasse A(3); // Aufruf des Konstruktors mit Parameter 3 -> A.x ist jetzt 3
       MeineKlasse B(); // parameterloser Aufruf -> Standardparameter 0 -> A.x ist 0
       MeineKlasse C; // auch parameterlos, auch hier wird der Standardkonstruktor genommen.
    


  • Nexus schrieb:

    //...
       MeineKlasse B(); // parameterloser Aufruf -> Standardparameter 0 -> A.x ist 0
    //...
    

    Ich glaube eher das er den B-Fall versucht als Funktionsaufruf zu werten...


  • Mod

    asc schrieb:

    Nexus schrieb:

    //...
       MeineKlasse B(); // parameterloser Aufruf -> Standardparameter 0 -> A.x ist 0
    //...
    

    Ich glaube eher das er den B-Fall versucht als Funktionsaufruf zu werten...

    fast. Es ist eine Funktionsdeklaration - hier passiert also schlicht und ergreifend gar nichts. Danke, C.


Anmelden zum Antworten