Vl kann mir ja einer von euch helfen ich häng irgendwie fest:

Ich mach gerade eine Klasse Object die als Basisklasse für RedBottle, BlueBottle... usw dient es gibt für beide Abgeleiteten Klassen je zwei bezeichner.

wenn ich red bottle noch nicht benutzt habe kenne ich den ersten bezeichner und wenn ich es benutzt habe kennt ich das gebräu und der 2te bezeichner bei allen RedBottle Objecten ausgegeben wenn ich danach frage.

bool Object::use() const
 {
  if (identified_)
   std::cout << "You used: " << name_identified_ << std::endl;

  else
   { 
    std::cout << "You used: " << name_not_identified_ << std::endl;
    identified_ = true;  
   } 

  return true;
 }

so halt in etwa aber wie mach ich dass, das dass fortan alle und nur die RedBottle Objecte den Zweiten bezeichner haben??? also identified_ für alle gleich ist.

dank im voraus für euer bemühen.

lg
EvilStuff

identified_ = true;

also ich hatte dann einen Compilerfehler.

lg
EvilStuff

in der Klasse

static bool identified_; // fuer was ist eigentlich der Unterstrich?

Und dann zusätzlich nochmal auserhalb der Klasse definieren:

bool Klasse::identified_ = false;

innerhalb der Klasse kannst du dann normal auf sie zugreifen.

Was hattest du denn für einen Compilerfehler?

bool Object::identified_(false);

ausserhalb der klasse definieren

thx an alle

also codingstandart halt

Ich mach gerade eine Klasse Object die als Basisklasse für RedBottle, BlueBottle... usw dient es gibt für beide Abgeleiteten Klassen je zwei bezeichner.

Was meinst Du mit "bezeichner" ?

EvilStuff schrieb:

wenn ich red bottle noch nicht benutzt habe kenne ich den ersten bezeichner und wenn ich es benutzt habe kennt ich das gebräu und der 2te bezeichner bei allen RedBottle Objecten ausgegeben wenn ich danach frage.

Ich verstehe nur Bahnhof. Schreibe mal Deutsch -- so mit Satzzeichen und korrekter Grammatik und so. Dann verstehen vielleicht mehr Leute, was Du willst.

EvilStuff schrieb:

[...]
so halt in etwa aber wie mach ich dass, das dass fortan alle und nur die RedBottle Objecte den Zweiten bezeichner haben??? also identified_ für alle gleich ist.

Erklär Dich mal besserer.

Ich versuchs nochmal:

Also ich hab eine Basisklasse Objects:

class Object
{
public:
  Object (std::string name_not_identified, std::string name_identified,
          std::string use_message);
  Object (const Object& orig);
  virtual ~Object ();
  virtual bool use() const;
  virtual void identifie();
  virtual std::string GetName();
  virtual void SetMsg(std::string& msg);

private:
  std::string name_identified_;
  std::string name_not_identified_;
  std::string use_msg_;
  static bool identified_;

};

So sehen die use() und die GetName() methode aus.

bool Object::use() const
{
   std::cout << use_msg_ << std::endl;
   identified_ = true;
 return true;
}

std::string Object::GetName()
{
 if(identified_)
   return name_identified_;
 else
 return name_not_identified_;
}

Und mehrere Klassen die von ihr abgeleitet sind. RedBotttle, BlueBottle ....
Alle abgeleiteten Klassen haben einen nicht identifizierten namen und einen identifizierten.

z.B.:
Wenn ich RedBottle noch nicht benutzt habe heißt diese eben Red Bottle. Wenn ich sie einmal benutzt habe ist sie bekannt und heißt fortan Poison.

Ich habs jetzt mit einer static bool identified_ ausprobiert wenn ich dann aber ein Object benutze sind alle Objecte bekannt.

// Object ist deine Basisklasse?
class Object { /* ... */ };

// Dann gibts nen Child RedBottle abgeleitet von Object?
class RedBottle : public Object { /* ... */ };

// Dann gibts nen Child BlueBottle abgeleitet von Object?
class BlueBottle : public Object { /* ... */ };

falls ja, dann gehört deine static in die jeweils abgeleiteten Klassen:

class RedBottle : public Object
{
    private:
        static bool identified_;
    /* ... */
};

bool RedBottle::identified_ = false;

Damit wird der Gültigkeitsbereich von identified auf die jeweils abgeleitete Klasse gelegt. Jede Instanz von RedBottle hat zugriff auf identified_ .
Dieser Wert darin ist für alle diese Instanzen gleich.

Prinzipiell ist es aber nicht so gut, die Objekte oder deren Inhalt über Strings zu identifizieren. Im Programmcode kannst du mal schnell nen Bock schießen der Kompiliert aber eben kein "Ich bin Gifitg" auslöst. Da sind enums besser. Oder allgemeine bool-Methoden wie "hurts()" o.ä.

Ich denke du schreibst eine Art Rollenspiel.
Deshalb die prinzipielle Frage: Sind in allen roten Flaschen giftige Substanzen? Wenn ja muss das identified_ als static bool in RedBottle. Ich denke aber nicht, dass man von der Farbe der Flasche auf den Inhalt schließen kann.

Jep. Leider somit ist die Wiederspielfreude futsch, denn ich weiß jetzt wenn ich eine Red Bottle im inventar hab iiiih nicht trinken. Aber so ist es halt in der Aufgabenstellung.

Habs jetz so wie oben gemacht.

Ich werd mir auf jedenfall den anderen Ansatz auch merken vl ändert sich ja was.

ich hab mir mal folgendes main zum testen geschrieben:

int main(int argc, char** argv)
{

 Object* MyArray[4];
 Object* ptr;
 Inventory inventory;

 for (int i=0; i < 4; i++)
 {
   switch(i)
   {
    case 0:ptr = new RedBottle;
    break;
    case 1:ptr = new BlueBottle;
    break;
    case 2:ptr = new RedBottle;
    break;
    case 3:ptr = new BlueBottle;
    break;
   }
    inventory.addToInventory(ptr);
    MyArray[i] = ptr;
 }

 inventory.listInventory();

  for (int i = 2; i > 0 ; i--)
 {
    inventory.useObjectAt(i);
 }

// for (int i = 0; i < 4; i++)
// {
//   MyArray[i]->use();
// }

 inventory.listInventory();

Wenn den auskommentierten teil mit ausführe funktioniert alles normal mit den namen.
Ich hab den Fehler schon eingegrenzt und er kann eigtl nur in folgender methode liegen:

bool Inventory::useObjectAt(int index)
{
   if ( index > inventory_.size() || index <= 0 )
  {
    std::cout << "You stare into the air around you - nothing there to "
                 "be used."<< std::endl;
    return false;
  }
  inventory_[index-1]->use(); // gibt einfach nur ne meldung aus und setzt identified auf true

  inventory_.erase(inventory_.begin() + (index-1));

  return true;
}

Mir ist aufgefallen, dass wenn ich inventory_.erase(inventory_.begin()+(index-1)); nicht ausführe, also kein Object gelöscht wird, auch die richtigen namen ausgegeben werden.

Hier auch noch die addToInventory Methode.

bool Inventory::addToInventory(Object* object)
{
 inventory_.push_back(object);
 std::cout << "You Picked up: " << object->GetName() << std::endl;
}

Ich hoffe das reicht an Info da es ne Aufgabe ist mächte ich nicht zu viel code verraten.

inventory_.erase(inventory_.begin() + index);

Passt es jetzt?

Ich programmiere zusammen mit anderen eine art rollenspiel.
Ich mache die Objecte und das Inventar.

Der Spielverlauf sieht so aus:
Das Spielfeld besteht aus Tiles auf denen Gegenstände liegen. Wenn ein Character
über einen Gegenstand läuft nimmt er ihn automatisch im Inventar auf. Man kann
eine Liste der aufgenommenen Gegenstände ausgeben. Ist eine Art von Gegenstand
wie z.B.: RedBottle noch nicht benutzt heißt diese "Red Bottle". Wurde diese
einmal benutz heißt sie "Poison" und alle anderen RedBottle die im Inventar und
noch am Spielfeld sind auch auch. Also wiederspielfreude ist futsch da du beim nächsten Spiel weißt wenn du eine RedBottle im Inventar hast "nicht trinken".

Also ich möchte die static bool in den beiden Klassen nach ihrem status fragen und in Object nutzen. Da ich dann mit allen erzeugten Gegenstände auf die methoden von Object zurückgreifen möchte.
Geht das

Also das folgende programm, was ihr 1:1 ubernehmen und compilieren könnt, sagt aus was ich will.

#include <stdlib.h>
#include <iostream>
class Object
{
public:
  Object(bool& identified) : identified_(identified){}; // ich dachte, da ich hier eine referenz übergeben bekomme weis object zur laufzeit immer wann
                                                        // Red- oder BlueBottle identified status hat.
  virtual void SetId(){ identified_ = true; }           // und hier dass ich damit die static in dem Object, dass ich aufrufe
  virtual bool GetId() const{ return identified_;}
  virtual bool bla() const{ return identified_;}
private:
  bool identified_;
};

class RedBottle : public Object
{
public:
  RedBottle () : Object(identified_){};
  RedBottle (const RedBottle& orig);
private:
  static bool identified_;
};

class BlueBottle : public Object
{
public:
  BlueBottle () : Object(identified_){};
  BlueBottle (const RedBottle& orig);
private:
  static bool identified_;
};

bool BlueBottle::identified_ = false;
bool RedBottle::identified_ = false;

int main(int argc, char** argv)
{
 RedBottle rB1;
 RedBottle rB2;
 BlueBottle bB1;
 BlueBottle bB2;
 std::cout << rB1.GetId();
 rB1.SetId();
 std::cout << rB1.GetId();
 std::cout << rB2.GetId();
 std::cout << bB1.GetId();
 bB1.SetId();
 std::cout << bB1.GetId();
 std::cout << bB2.GetId();
 return(EXIT_SUCCESS);
}

Wenn ihr das Programm aussführt bekommt ihr 010010 als ausgabe.
ich bräuchte aber 011011 :p War ein komischer Zufall mit der ausgabe Ich hab
gar nicht dran gedacht, dass ich dann ja so ne Art Binärcode erhalte find ich
aber witzig.

thx und good n8

class Object
{
public:
  Object(bool& identified) : identified_(identified){}; // ich dachte, da ich hier eine referenz übergeben bekomme weis object zur laufzeit immer wann
                                                        // Red- oder BlueBottle identified status hat.
  virtual void SetId(){ identified_ = true; }           // und hier dass ich damit die static in dem Object, dass ich aufrufe
  virtual bool GetId() const{ return identified_;}
  virtual bool bla() const{ return identified_;}
private:
  bool& identified_;  // muss eine Referenz sein.
};

Gruß
sonic