ich habe ein problem mit selbsterstellten klassen.Und zwar habe ich eine Elternklase, die über 2 Kinder verfügt, die die elternklasse um eine je eine methode erweitertn.

class eltern
{
	public:
		eltern(void);
		virtual ~eltern(void);
		virtual void tuwas(int i){;};
	protected:
		int a;
		double b;
};

class kind1 : public eltern
{
	public:
	       void setkind1attribut(int i);
               void tuwas(int i);
	private:
		int kind1attribut;
};

class kind2 : public eltern
{
	public:
	       void setkind2attribut(int i);
               void tuwas(int i);
	private:
		int kind2attribut;
};

wenn ich jetzt ein Array: eltern test[5] erstelle, und das beliebig mit kind1 / kind2 fülle, wie kann ich dann auf die methoden der kinder zugreifen?bzw wie kann ich einen typecast von einem eltern-element aus dem array auf ein kind1 bzw kind2 machen? muss ich dafür in den kindern eine spezielle methode schreiben, die mir einen typecast ermöglicht?

Vielen dank schonmal für hilfe!

MfG

Quaki

Was soll das da sein:

virtual void tuwas(int i){;};

Änder das lieber in:

virtual void tuwas( int i ) = 0;

Ebenso wie diese Methoden:

void setkind1attribut(int i);
void setkind1attribut(int i);

Eine virtuelle Methode + zwei Überladungen.
Dann musst du nicht entscheiden ob es sich um Kind1 oder Kind2 handelt.

grüße

grüße

Okay, gut das du mich wiederholst!

ups!

Entweder du machst nen Array aus Zeigern (eltern*[5]) oder (besser) einen std::vector<eltern*>

Ich würde ja gerne nen Typecast machen, aber der Compiler lässt micht nicht...

muss ich in meiner Unterklasse eine bestimmte methode implementieren, um überhaupt einen typecast machen zu können?

Warum willst du casten? Eigentlich sollte man NIE casten, nur dann wenns wirklich nich anders Möglich ist.

class Test
{
  virtual void setAttribute() = 0;
}

class Test1 : public Test
{
  void setAttribute() {}
}

class Test2 : public Test
{
  void setAttribute() {}
}

//..
std::vector< Test *> v;

v.push_back( new Test1 );
// ...

So brauchst du keinen cast sondern rufst jeweils immer einfach iterator.setAttribute() auf, fertig.

grüße

Wie sähe denn eine lösung mit pointern aus?

Sehe ich das richtig, das ich 2 Kontainer haben muss, da ich ja nur so die attribute speichern kann, die zwar in den unterklassen nicht aber in der basisklasse vorkommen?!

danke für die hilfe schonmal im vorraus!

Wenn du weist was für ein Typ dein Pointer ist, kannst du diesen casten und die entsperchenden Funktionen aufrufen, leider weist du das nicht.
Du kannst mit dem operator typeid den Typ zwar rausbekommen, zum einen muss dann aber die RTTI verfügbar sein zum anderen hattet ihr das wohl auch nicht in der Vorlesung.

grüße

Ne, wenn du weist an welcher stelle was für ein Typ steht kannst du auch casten...

Kind1 *p = static_cast< Kind1 >( array[ index ] );
p->tuirgendwas();

In array[ index ] muss natürlich wirklich der Typ "Kind1" vorhanden sein. Und außerdem ist casten sowiso gefährlich, kanns garnicht oft genug sagen.

grüße

#include <iostream>
using namespace std;

struct Base
{
};

struct Derived1 : Base
{
  int getVal()
  {
     return 13;
  }
};

struct Derived2 : Base
{
  const char* getName()
  {
     return "Hello World";
  }
};

int main()
{
  Base* objects[10];

  for( int i = 0; i < 10; ++i )
  {
      if( i % 2 == 0 )
          objects[ i ] = new Derived1;
      else
          objects[ i ] = new Derived2;
  }

  for( int i = 0; i < 10; ++i )
  {
      //rausfinden ob das Objekt ein Derived1 ist
      if( Derived1* p = dynamic_cast< Derived1* >( objects[ i ] ) )
          cout << p->getVal() << endl;
      else//wenn nicht ist es ein Derived2
      {
          Derived2* p = static_cast< Derived2* >( objects[ i ] );
          cout << p->getName() << endl;
      }
  }

  for( int i = 0; i < 10; ++i )
     delete objects[ i ];
}

Allerdings glaube ich, dass dir noch nen paar allgemeine Grundlagen in Sachen Vererbung fehlen, oder ihr noch nicht genug gemacht habt damit du richtig damit umgehen kannst.

#include <iostream>
using namespace std;

struct Base
{
	virtual ~Base(){}
};

struct Derived1 : Base
{
	int getVal()
	{
		return 13;
	}
};

struct Derived2 : Base
{
	const char* getName()
	{
		return "Hello World";
	}
};

int main()
{
	Base* objects[10];

	for( int i = 0; i < 10; ++i )
	{
		if( i % 2 == 0 )
			objects[ i ] = new Derived1;
		else
			objects[ i ] = new Derived2;
	}

	for( int i = 0; i < 10; ++i )
	{
		//rausfinden ob das Objekt ein Derived1 ist
		if( Derived1* p = dynamic_cast< Derived1* >( objects[ i ] ) )
			cout << p->getVal() << endl;
		else//wenn nicht ist es ein Derived2
		{
			Derived2* p1 = static_cast< Derived2* >( objects[ i ] );
			cout << p1->getName() << endl;
		}
	}

	for( int i = 0; i < 10; ++i )
		delete objects[ i ];
}

was wäre denn jetzt wenn es in Derived1 ein attribut

int val

gäbe, und in Derived2 ein attribut

char[20] name

jeweils mit einer get und einer set methode.

kann ich das attribut überhaupt mit hilfe in einem Objekt auf das ich mit dem Base* Array zugreife speichern? oder geht das nur wenn ich 2Arrays Derived1[] und Derived2[] mache?

Mfg

Quaki

kann ich das attribut überhaupt in einem Objekt auf das ich mit dem Base* Array zugreife speichern? oder geht das nur wenn ich 2Arrays Derived1[] und Derived2[] mache?