3. std::map<String,TEigeneKlasse> Wie initialisiere ich davon neue Elemente?

std::map<String,TEigeneKlasse> Wie initialisiere ich davon neue Elemente?

  • G

    Hallo, ich hab folgendes Problem (Borland C++ Builder 6.0 - aber egal da es ein Grundlegendes C++ Problem ist):

    //Wird in einer Header Datei definiert

std::map<String,TEigeneKlasse> Test;

//In einer Cpp gibt es nun eine Funktion die soetwas können soll:

Test["Hallo"]=TEigeneKlasse(); 

// Jedoch wird ja hierbei nur lokal TEigeneKlasse erzeugt, oder und ist nicht 
//im restlichen Programm verfügbar

//alternativ dachte ich an:

std::map<String,TEigeneKlasse*> Test;

// und damit

Test["Hallo"]=new TEigeneKlasse();

// Aber das ging leider auch nicht.

    So und hier mal der Orginal Code:

    // Hier der Header

class TCharakter;
class TGegner;

class TWaffenEigenschaften
{
private:
        friend class TCharakter;
        friend class TGegner;
        short KKZuschlag;
        short Bruchfaktor;
        short Waffenvergleichswert1;
        short Waffenvergleichswert2;
        short AT;
        short PA;
        short Schadenswuerfel;
        short Wuerfelart;
        short Schadenszuschlag;
        bool Einhand;
        bool Rechts;
        AnsiString Kategorie;

        void setWaffenWerte(short,short,short,short,short,short,short,short,short,bool,bool,AnsiString);
        TWaffenEigenschaften(short,short,short,short,short,short,short,short,short,bool,bool,AnsiString);

public:

        TWaffenEigenschaften();

        short getKKZuschlag();
        short getBruchfaktor();
        short getWaffenvergleichswert1();
        short getWaffenvergleichswert2();
        short getAT();
        short getPA();
        short getSchadenswuerfel();
        short getWuerfelart();
        short getSchadenszuschlag();
        bool EinhandWaffe();
        bool rechtsgefuehrt();
        AnsiString getKategorie();

};

class TCharakter
{
private:

        std::map<AnsiString,short> Werte;

        std::map<AnsiString,short> Ruestung;

        std::map<AnsiString,TWaffenEigenschaften> Waffen;

        struct TSchild
        {
          bool ATPA;
          short ATAbzug;
          short PABonus;
          short RSBonus;
          TSchild():ATPA(true),ATAbzug(0),PABonus(0),RSBonus(0){}
        }Schild;

        Exception *exception;

public:

        TCharakter();
        ~TCharakter();
        void loadCharakter(AnsiString);//MUß noch implementiert werden!
        void saveCharakter(AnsiString);//MUß noch implementiert werden!
        void showCharakter();          //MUß noch implementiert werden!
        void setWaffe(AnsiString,short,short,short,short,short,short,short,bool,bool,AnsiString);
        void deleteWaffe(AnsiString);
        void setRuestung(AnsiString,short);
        void setSchildATPA(bool);
        void setSchildATAB(short);
        void setSchildPABO(short);
        void setSchildRSBO(short);
        void setWert(AnsiString,short);
        const TWaffenEigenschaften& getWaffe(AnsiString);
        short getSchildATAbzug();
        short getSchildPABonus();
        short getSchildRSBonus();
        bool getSchildATPAModus();
        short getRuestung(AnsiString);
        void Berechne();
        short getWert(AnsiString);
        const std::map<AnsiString,TWaffenEigenschaften> getWaffen();

};

// Hier in der Implementation *.cpp

void TCharakter::setWaffe(AnsiString Waffe,short KKZu,short Bruchf,short WVW1,short WVW2,short SWuerfel,short WArt,short SZuschlag,bool EinhandW,bool RechtsG,AnsiString Kat)
  {
   // Achtung die Behinderung BE muß später betrachtet werden!
   short At=0,Pa=0;
   bool gueltig=true;

   if (Kat=="Äxte und Beile")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Dolche")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Infanteriewaffen")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Kettenwaffen")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Peitsche")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Scharfe Hiebwaffen")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Schwerter")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Speere und Stäbe")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Stichwaffen")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Stumpfe Hiebwaffen")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Zweihänder")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Lanzenreiten")
   {
     At=Werte[Kat+"AT"]+Werte["ATBasis"];
     Pa=Werte[Kat+"PA"]+Werte["PABasis"];
   }
   else if (Kat=="Bogen")
   {
     At=Werte[Kat+"AT"]+Werte["FKBasis"];
   }
   else if (Kat=="Blasrohr")
   {
     At=Werte[Kat+"AT"]+Werte["FKBasis"];
   }
   else if (Kat=="Wurfaxt")
   {
     At=Werte[Kat+"AT"]+Werte["FKBasis"];
   }
   else if (Kat=="Wurfdolch")
   {
      At=Werte[Kat+"AT"]+Werte["FKBasis"];
   }
   else if (Kat=="Wurfspeer")
   {
      At=Werte[Kat+"AT"]+Werte["FKBasis"];
   }
   else if (Kat=="Schleuder")
   {
     At=Werte[Kat+"AT"]+Werte["FKBasis"];
   }
   else {gueltig=false;}

   if (gueltig)
   {
     if (!RechtsG)
     {
       At=At-7+Werte["LinkshändigAT"];
       if (Pa!=0)
       {
         Pa=At-7+Werte["LinkshändigPA"];
       }
     }
     std::map<AnsiString,TWaffenEigenschaften>::iterator iter=Waffen.begin();
     while ((iter!=Waffen.end())&&(iter->first!=Waffe))
     {
       iter ++;
     }
     if (iter!=Waffen.end())
     {
       iter->second.setWaffenWerte(KKZu,Bruchf,WVW1,WVW2,At,Pa,SWuerfel,WArt,SZuschlag,EinhandW,RechtsG,Kat);
     }
     else
     {

// HIER SOLLTE DAS PROBLEM SEIN:

       Waffen[Waffe]=TWaffenEigenschaften(KKZu,Bruchf,WVW1,WVW2,At,Pa,SWuerfel,WArt,SZuschlag,EinhandW,RechtsG,Kat);
     }
   }
}

// WENN ICH DANACH FOLGENDE METHODE AUFRUFE WIRD DIE exception GEWORFEN
// AUCH WENN DER NAMENSSTRING Waffe übereinstimmen müßte, ...

const TWaffenEigenschaften& TCharakter::getWaffe(AnsiString Waffe)
  {

    std::map<AnsiString,TWaffenEigenschaften>::iterator iter=Waffen.begin();
    while ((iter!=Waffen.end())&&(iter->first!=Waffe))
    {
      iter ++;
    }
    if (iter->first==Waffe)
    {
      return iter->second;
    }
    else throw exception;

  }
    0
  • G

    Wenn ich etwas á la

    std::map<string,int> Test;

    hab, kann man es ja auch einfach initialisieren mit:

    Test["Erster Wert"]=5;
    0
  • ?

    Wie sieht dein copy-ctor aus und wo ist dein Zuweisungsoperator definiert ?
    Um Klassen in einem STL-Container verwalten zu können müssen Sie einige Standardfunktionen implementieren.

    Ich vermute dass es daran liegt. Deine Daten werden nicht richtig kopiert.

    0
  • G

    Autsch, stimmt hast recht, die beiden hab ich irgendwie totall vergessen 😮

    Dachte den Copy-Konstruktor kann ichm ir sparen, aber stimmt, dann wird ja nur elementweise kopiert und dann wird sicher irgendwo nur eine Speicheradresse kopiert und diese nach der Methode gelöscht ... oder?

    0
  • B

    Hallo,

    Der standardmässig erzeugte CopyCtor sollte bei deiner Klasse eigentlich reichen.
    Ich finde deine Methode in deiner map zu suchen auch reichlich umständlich und fehleranfällig. Warum verwendest du nicht find.
    Der Code in getWaffe geht sowieso daneben, wenn dieser Eintrag nicht existiert. Du versuchst dann nämlich end() zu dereferenzieren.

    0
  • G

    Jo, das mit dem end() ist mir auch schon aufgefallen, habs mal gerade noch korrigiert, funktionierte sonst nämlich merkwürdigerweise auch (naja vielleicht dank Borland)

    An find hatte ich ehrlich gesagt gar nicht gedacht *g*

    Wie würdet ihr denn das mit der Zuweisung machen?

    std::map<AnsiString,TWaffenEigenschaften*> Waffen;
Waffen["Schwert"]= new TWaffenEigenschaften();

    oder

    std::map<AnsiString,TWaffenEigenschaften> Waffen;
Waffen["Schwert"]= TWaffenEigenschaften();

    Wenn ich Waffen["Schwert"]= schreibe wird doch der Konstruktor von TWaffenEigenschaften ohnehin aufgerufen, oder nicht - oder was macht die map dann? Denn bei

    std::map<int,int> Test;
// wird doch mit 
Test[1]=1 
//auch der Speicherplatz festgelegt ,...
    0
  • G

    So ich hab mal den Zuweisungsoperator definiert, hat mir aber lieder nix gebracht:

    TWaffenEigenschaften& TWaffenEigenschaften::operator= (const TWaffenEigenschaften& Waffe)
  {
    this->KKZuschlag=Waffe.getKKZuschlag();
    this->Bruchfaktor=Waffe.getBruchfaktor();
    this->Waffenvergleichswert1=Waffe.getWaffenvergleichswert1();
    this->Waffenvergleichswert2=Waffe.getWaffenvergleichswert2();
    this->AT=Waffe.getAT();
    this->PA=Waffe.getPA();
    this->Schadenswuerfel=Waffe.getSchadenswuerfel();
    this->Wuerfelart=Waffe.getWuerfelart();
    this->Schadenszuschlag=Waffe.getSchadenszuschlag();
    this->Einhand=Waffe.EinhandWaffe();
    this->Rechts=Waffe.rechtsgefuehrt();
    this->Kategorie=Waffe.getKategorie();
    return *this;
  }

    Dann hab ich es mal mit

    insert

    anstelle von

    Waffen[Waffe]=

    versucht, bringt auch noch keine Verbesserung:

    Waffen.insert(pair<AnsiString,TWaffenEigenschaften>(Waffe,TWaffenEigenschaften(KKZu,Bruchf,WVW1,WVW2,At,Pa,SWuerfel,WArt,SZuschlag,EinhandW,RechtsG,Kat)));

    Irgendwie scheint das neue Element nicht in die Map eingefügt zu werden, kann das sein? *verzweifel*

    0
  • G

    So hat sich erledigt, onchmal danke an alle.

    ➡ der Fehler lag an einer anderen Stelle, gatte ausversehen eine Kopie eines Objektes und nicht einen Zeiger darauf zurück gegeben - dummer Fehler, aber nicht zu ändern.

    Falls hier jemand aufräumt, kann das hier gelöscht werden!

    0
Anmelden zum Antworten