Es ghet darum dass eine Klasse a erstellt werden soll deren Objekte Variablen vom Typ string und Integer enthalten sollen:

class A
{
public:
int id ;
string name ;
};

a Objekt1 ;

Objekt1.id = 1 ;
Objekt1.name = "test" ;

Dann soll eine zweite Klasse b erstellt werden, die ähnliche oder gleiche Eigenschaften hat.

Das Ziel ist dass ein Objekt der Klasse a ebenso ein 'Tochterobjekt' der klasse b sein kann:

a.b.id = 1 ;

Wie ließe sich das umsetzen?

serbud schrieb:

Das Ziel ist dass ein Objekt der Klasse a ebenso ein 'Tochterobjekt' der klasse b sein kann:

Sein kann oder sein muss? Um etwas dynamik reinzubringen:

std::vector<std::vector<A>> a

Ansonsten müsste man wissen was du vor hast, da gibt es sicherlich auch noch andere Wege...

Dann soll eine zweite Klasse b erstellt werden, die ähnliche oder gleiche Eigenschaften hat.

Das Ziel ist dass ein Objekt der Klasse a ebenso ein 'Tochterobjekt' der klasse b sein kann:

Verwendest Du "Objekt" und "Klasse" synonym? In Deinem Beispiel ist a ein Objekt der Klasse A .

serbud schrieb:

a.b.id = 1 ;

Was soll das denn?

Kannst Du deutlicher beschreiben, was Du machen willst?

Gruß,
SP

Nehmen wir an ich würde in einer Klasse via struct einen Datentyp erstellen. Die Elemente des struct spreche ich dann ja ähnlich wie die Variablen einer Klasse syntaktisch so an:

a.eigenschaft

Wenn nun dieses struct in der klasse verwendet werden soll, wie spreche ich die Elemente an?

Zeig mal genau, was du machen willst. (und probiere dich so präzise an die Syntax von C++ zu halten, dass wir auch verstehen können, was du meinst).

Verschachtelte Typen sollten mit Bedacht eingesetzt werden. Sie machen oft im private -Teil Sinn (als Implementierungsdetail), aber grundsätzlich braucht man sie nicht allzu oft...

Aber um die ursprüngliche Frage zu beantworten: Du musst wie bei jedem Typ eine Membervariable erstellen:

class Outer
{
    class Inner
    {
    };
    Inner Var; // <-- deine Variable
};

Der Zugriff sollte wenn möglich gekapselt erfolgen, also über Methoden der Klasse. struct s bieten keinen Schutz diesbezüglich (sind aber dennoch manchmal sinnvoll, kommt auf die Anwendung an).

class A
{
public:
    B  _b;
};

class B
{
public:
    int TollerInteger;
    std::string TollerString;
};

int main()
{
A ObjektA;

ObjektA._b.TollerInteger = 1;
ObjektA._b.TollerString = "Aber Hallo!";

return ObjektA._b.TollerInteger;
}

Sollte so funktionieren :p

bb

Man stelle es sich ein Videospiel vor. Es gibt 2 oder mehr Fraktionen. Jede Fraktion hat unterschiedliche Charaktertypen die sich in ihren Eigenschaften unterscheiden.

Mein Konzept würde nun für jede Fraktion ersteinmal eine Klasse erstellen. In diese Klasse werden fraktionsgrundlegende Funktionen eingeführt, wie z.B baue ein Haus.

Dann möchte ich für jeden Charaktertyp eine eigenständige Klasse führen um seine Fähigkeiten und Attribute verwalten zu können. So hätte zum Beispiel die Klasse zauberer der Fraktion a die Funktionen Zaubern und die Attribute Zauberkraft(int) und Name(string).

Da nun die eine Klasse nur zusammen mit der anderen klasse existieren kann, weil nur diese Fraktion den Zauberer besitzt, müsste ich diesen ja ansprechen können:

Fraktion_A.Zauberer.zauberkraft = 100 ;

Man stelle es sich ein Videospiel vor. Es gibt 2 oder mehr Fraktionen. Jede Fraktion hat unterschiedliche Charaktertypen die sich in ihren Eigenschaften unterscheiden.

Trotzdem würde ich es nicht so doll im Quellcode festlegen, welche Fraktion welchen Zauberer haben darf...
Ich würde "ganz normal" die Klasse Zauberer usw. schreiben und die Auswahl auslagern.
die spez. fähigkeiten würde ich vermutlich durch ne virtuelle basisklasse regeln:

struct character
{
  int hp;
  int mana;
};

struct horde_character : virtual character
{
  virtual void baue_haus()
  {
    throw "darfst du gar nicht - oder hats der programmierer vergessen, zu implementieren?^^";
  }
};

struct dings_character : virtual character
{};

struct ich_kann_so_gar_ganz_vielen_fraktionen_angehören_und_jede_spezialfähigkeit
  : dings_character, horde_character
{
/*..*/
};

struct zauberer : horde_character
{
  void baue_haus()
  {
    mana = 0; //der baut ja wohl nicht selbst, sondern lässt bauen
    hp -= hp/100; //vll verletzt er sich ja beim zaubern^^
  }
}

Da Fraktionen vermutlich viele versch. Typen haben können, würde ich wohl ne map<klassen_bezeichner, ptr_vector<basis_klasse_der_charakter>> nehmen.

Spricht da iwas dagegen? es würde auch ohne die basis_klasse gehen, aber ich würd sie zumindest für sinnvoll erachten(alle haben hp, alle ne rüstung, alle ne waffe, alle mana, alle können laufen->haben ne (lauf-)geschwindigkeit) - irgendwie so was in der richtung)

bb

PS: Kann sein, ich verstehe was falsch, aber:

class Auto
{
public:
  struct Tscheibenwischer
  {
    int kilometerstand; //^^

    /*explicit*/ scheibenwischer(int km = 0) : kilometerstand(km) {}
  } scheibenwischer;

  Auto() : preis(-1), scheibenwischer(0) {}
  int preis;
};

int main()
{
  Auto mercedes;
  mercedes.scheibenwischer.kilometerstand = 123;
}

geht doch und tut gena das, was du dir vorgestellt hast!?
ich würds trotzdem nicht so machen^^
stell dir mal vor, es gibt später charakter, die in beiden fraktionen gespielt werden dürfen...

wenn ichs mir richtig überlege, würd ich das da oben so gar noch weiter aufteilen:

struct character_base { int hp; };

struct kann_haus_bauen : virtual character_base
 { void haus_bauen() {} };
struct kann_schlitten_fahren : virtual character_base
 { void fahr_schlitten() {} };
struct kann_luft_zum_riechen_bringen : virtual character_base
 { void zauber() {} };
struct kann_tierbabys_verspeisen : virtual character_base
 { void ess() {} };

struct fraktion_one_character : kann_tierbybs_verspeisen, kann_haus_bauen
{};

struct fraktion_two_character : kann_luft_zum_riechen_bringen, kann_haus_bauen
{};

struct fraktion_three_character : kann_tierbybs_verspeisen, kann_schlitten_fahren, kann_haus_bauen
{};

struct fraktion_four_character : kann_tierbybs_verspeisen, kann_haus_bauen
{};

struct zauberer : fraktion_one_character, fraktion_three_character, fraktion_four_character
 {};

struct kameltreiber : fraktion_two_character
 {};

bb

Was das Schlüsselwort virtual nun genau bewirkt ist mir allerdings noch nicht ganz klar. Laut Lehrbuch wird dem Compiler damit signalisiert dass ein Objekt selbst entscheidet welche Funktion es aufruft.

Über eine genauere Erklärung würde ich ich freuen da auch die Refferenz nicht wirklich schlüssig war.

das problem, was dieses virtual beseitigen soll ist auch unter diamant-problem bekannt.
in dem artikel ist so gar noch mal explizit nen link zu nem C++ Bsp.

zumindest der zweite link sollte dir all deine fragen beantworten ;o)
wenn du das gelesen hast und trotzdem noch fragen hast, kannst du ja noch mal fragen...

bb

Um kein neues Thema eröffnen zu müssen:

Wenn ein Programm in einem bestimmten Fall ein neues Objekt einer Klasse erzeugen soll (Zum Beispiel einen neuen Zauberer wenn der Spieler einen kauft), dann würde das doch in etwa so aussehen:

if (build_wizard == true)
{
new Wizard ;
}

Wie richte ich es allerdings ein die vorhanden Zauberer zu Zählen und ihnen Aufsteigende Namen zu geben, wenn er automatisch erzeugt wird?

Um kein neues Thema eröffnen zu müssen:

mach das nächste mal bei ner anderen frage bitte nen anderen thread auf

Wenn ein Programm in einem bestimmten Fall ein neues Objekt einer Klasse erzeugen soll (Zum Beispiel einen neuen Zauberer wenn der Spieler einen kauft), dann würde das doch in etwa so aussehen:

if (build_wizard == true)
{
new Wizard ;
}

naja - (genau) so sollte es auf keinen fall aussehen : D

Wie richte ich es allerdings ein die vorhanden Zauberer zu Zählen

std::vector<TZauberer> zauberer;

if(want_a_new_hokuspokus)
  zauberer.push_back(TZauberer());

und ihnen Aufsteigende Namen zu geben, wenn er automatisch erzeugt wird?

was auch immer aufsteigende namen sind, evtl so:

unsere basisklasse von oben

template <typename T>
std::string ToStr(const T &conv)
{
    std::string R;
    std::stringstream ss;
    ss << count;
    ss >> R;
    return R;
}

std::string get_unique_name()
{
    std::string R;
    static std::size_t count = 0;
    R = "char" + ToStr(count);
    return R;
}

struct character
{
  int hp;
  int mana;

  std::string name;

  character()
  : name(get_unique_name()), hp(987), mana(1)
  {}
};

allerdings hab ich langsam das gefühl, dass du noch nicht weit genug für ein solches spiel bist (kann auch täuschen, will dich nich beleidigen) - evtl solltest du dich erst mal mit vererbung etc beschäftigen und dann nen konzept machen, wie du das spiel aufbaust (welche klasse braucht welche andere, wie arbeiten die zusammen, welche member, hierarchien, ...) und dann evtl. noch mal nen neuen thread aufmachen und fragen, ob dein ansatz so gut aussieht oder iwelche schwächen/nachteile hat.
erst dann solltest du anfangen, zu programmieren...

bb

allerdings hab ich langsam das gefühl, dass du noch nicht weit genug für ein solches spiel bist

Das ist definitiv so

Ich plane auch nicht ein großartiges Spiel zu programmieren, mir ging/geht es bei dem Beispiel nur darum dass System der Klassen/OOP besser verstehen und umsetzen zu lernen.

Noch einmal, vielen Dank für deine bisherigen Tipps ohne hätte ich vielleicht schon aufgegeben.

Ich gehe mich nun erstmal nach geeigneter Print-Lektüre umsehen.

Noch einmal, vielen Dank für deine bisherigen Tipps ohne hätte ich vielleicht schon aufgegeben.

np - die letzten tage war hier so wenig los, dass ich so gar schon fast freiwillig in die uni gegangen bin

hf gl