Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
30.11.2009, 15:07 Uhr
~Fragender
Gast

Hallo,

ich habe eine templatebasierte klasse C<T>.

Und ich habe eine abstrakte Klasse A von der 2 andere Subklassen A1 und A2 erben.
Nun will ich in einer Methode von A1 auf eine Methode von C<T> zugreifen. Schaffe ich das?

Ich habe es bisher nicht geschafft da ich ja nicht A einfach templatebasiert schreiben kann und an die subklassen durchreichen kann.

Gäbe es da eine Möglichkeit?

Danke

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
30.11.2009, 15:50 Uhr
~Fragender
Gast

also ein kleiner pseudocode dann so:

der template ansatz

C++:

    class C1
{
  void fooC ();
};

class C2
{
  void fooC ();
};

template<typename T>
class C
{
  void bar ()
  {

  }

  void myfoo ()
  {
   T t;
   t.fooC (  );
  }
};

und jetzt in verbindung mit vererbung

C++:

    class Base
{
public:
    virtual ~Base();
    virtual void basefoo() = 0;
};

class A1 : public Base<T>
{
public:
    virtual void foo<T>(T *myC)
    {
        myC->myfoo();
    }
};

class A2 : public Base<T>
{
public:

    virtual void foo(T *myC)
    {
       myC->myfoo();
    }
};

und irgendwo in main dann

C++:

//irgendwo in main z.B.
C<C1> myC;

Base * base = new A1();
base.foo(&myC);

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
30.11.2009, 16:36 Uhr
0xdeadbeef
Gott
(Operator)

Äh...jedenfalls nicht so - ein Zeiger auf Base kann nur das Interface von Base bedienen, und das sollte so angelegt sein, dass es für die Anwendung ausreicht.

Wenn ich richtig verstehe, was du da vorhast, dann ginge das etwa so:

C++:

class basic_C {
public:
  // Basisklassen sollten immer einen virtuellen Destruktor haben
  virtual ~basic_C();

  virtual void myfoo() = 0;
};

template<typename T> class C : public basic_C {
public:
  virtual void myfoo() {
    T t;
    t.fooC();
  }
};

// Und in der .cc

basic_C::~basic_C() { }

Und dann

C++:

class Base {
public:
  virtual ~Base();

  virtual void foo(basic_C &) = 0;
};

class A1 : public Base {
public:
  virtual void foo(basic_C &);
};

// .cc:

Base::~Base() { }

void A1::foo(basic_C &c) {
  c.myfoo();
}

und benutzen wie folgt:

C++:

C<C1> myC; // C1 braucht hierfür eine fooC-Methode

A1 a1;
Base &base = a1;
base.foo(myC);

--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 30.11.2009 um 16:37 Uhr von 0xdeadbeef editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
01.12.2009, 11:28 Uhr
~Fragender
Gast

Vielen Dank deadbeef. so hatte ich das gemeint und versuche gerade nachzuvollziehen warum es so funktioniert

Danke!

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
01.12.2009, 15:17 Uhr
0xdeadbeef
Gott
(Operator)

Ich habe ein bisschen die Vermutung, dass das Hauptverständnisproblem die Natur von Templates (Vorlagen) ist. Ist wahrscheinlich auch nicht deine Schuld; es gibt viele schlechte Bücher über C++, in denen von Template-Klassen und Template-Funktionen die Rede ist.

Es ist wichtig zu verstehen, dass Klassenvorlagen keine Klassen und Funktionsvorlagen keine Funktionen sind. In meinem Beispiel oben ist C keine Klasse. Lies das gern zweimal, es ist wichtig. Es handelt sich bei C um eine Vorlage für eine Klasse, die zu verschiedenen Klassen konkretisiert werden kann. Zum Beispiel ist C<C1> eine aus C konkretisierte Klasse.

Dementsprechend kannst du C auch nicht wie eine Klasse behandeln. Es ist zum Beispiel nicht möglich,

C++:

void foo(C const &c); // FALSCH!

zu schreiben, weil Parameter Typen sein müssen und C keiner ist (sondern lediglich eine Vorlage für einen).

Was ich oben mache, ist, eine abstrakte Basisklasse basic_C zu definieren, die das Interface bereitstellt und von der alle aus C konkretisierten Klassen erben, so dass alle aus C konkretisierten Klassen als Typ basic_C behandelt werden können. Ob du sie dabei als Referenz oder als Zeiger weiterleitest - naja, in der Regel sind Referenzen hübscher, weil man sich schon sehr anstrengen muss, um eine Referenz ins Nichts zeigen zu lassen, aber funktionieren wird beides.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
03.12.2009, 18:06 Uhr
~Fragender
Gast

Öha. Vielen Dank für die genaue Beschreibung. Diese hilft mir weiter - danke Dir für deine Erfahrungswerte. Ich knabbere an dem Verständnis aber ich gebe nicht auf. Dein Ansatz ist bereits implementiert und funktioniert wunderbar. Doch ich möchte es auch 100% verstehen...
Vielen Dank erneut

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: