Templates in virtueller methode

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

*rant*

Ich verstehe nicht ganz, was du tun willst, aber es klingt mir nach einem Designfehler. Dein Code ist irgendwie so:

template<typename T>
class C
{
};

class A
{
};

class A1 : public A
{
public:
    void methode()
    {
        // Was willst du hier tun?
    }
};

class A2 : public A
{
};

MfG

danke - so ist der code genau.

Ich wollte sowas schaffen:

der template ansatz

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

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

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

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

*rant*

Du willst also eine virtuelle Templatemethode, der du dann C<C1>, C<C2>, C<xy> übergeben kannst? Das ist nach dem aktuellen C++ Standard AFAIK nicht erlaubt, du musst für deine Templateklasse C<T> eine nicht-template-Basisklasse haben, welche eine Methode für den Aufruf bereitstellt und diese dann als Argument für eine normale Methode verwenden.

C++/CLI unterstützt virtual generics, was dem was du willst wohl am nächsten kommen würde, aber hier nicht verwendet werden kann.

MfG

Sebastian Pizer

Gambo schrieb:

class C1
{
  void fooC ();
};

class C2
{
  void fooC ();
};

hast wohl ein public: vergessen.

Gambo schrieb:

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

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

und jetzt in verbindung mit vererbung

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();
    }
};

Was ist T? Und warum benutzt Du Base wie ein Klassentemplate? Wo wird denn basefoo überschrieben? Was soll T *myC als Parameter von A1::foo bzw A2::foo? Warum gibt es überhaupt Base?

Gambo schrieb:

und irgendwo in main dann

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

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

A1 ist immernoch abstrakt. new A1 geht also nicht. Was für ein foo rufst Du denn da auf?

Kannst Du das nochmal erklären, was Du eigentlich bezwecken willst? Der Code allein ergibt für mich wenig Sinn. Ich schätze, Du bist mit den Sprach-Features, die C++ bietet, einfach überfordert. Statt ein Design-Ansatzes zu geben, sag am besten, was Du willst und man kann Dir Vorschläge machen, wie man es am besten umsetzt.

Gruß,
SP