pure virtual functions und templates?

[DerTod2k]

Ich bin gerade beim Programmieren auf ein Problem gestoßen,
auf das ich im Moment bei Google keine Antwort finde.
Angenommen ich habe eine Interface-Klasse, die nur aus
pure virtual Funktionen besteht. Jetzt brauche in in dieser
Klasse eine template Funktion.


class iBase
{
public:
template<class T>
virtual T* bla(...) = 0;
};


gcc sagt dazu:


invalid use of `virtual' in template declaration


Geht das überhaupt?

cu DerTod2k

[ethrandil]

ich hab zwar kaum ahnung davon, aber sollte da nicht ein Simikolon hinter der templatedeklaration stehen?

class iBase
{
public:
template<class T>;
virtual T* bla(...) = 0;
};

[Gnafoo]

Nein .. das ist Absicht, weil die zwei Zeilen zusammengehören
(sonst wird die Zeile so ewig lang)..

Und bevor jemand fragt :) die "..." als Parameter sind nur
stellvertretend .. da stehen eigentlich nur ganz normale
Parameter ..

Eigentlich ist das sowas:

template<class T> virtual T* bla(int egal) = 0;


cu DerTod

[Achill]

Ein Beispiel für Templeats :



#include <conio.h>
#include <iostream.h>

template <class T, class S>
class vector
{
public:
vector(S length) { data = new T[length]; this->groesse = length-1; };
~vector();
T & operator[](S index);
S getLength() {return this->length};

protected:
T * data;
S groesse;
};

template <class T, class S>
vector<T,S>::~vector()
{
if(this->data!=0){
delete[] this->data;
this->data = 0;
this->groesse = 0;
}
}

template <class T, class S>
T & vector<T,S>:: operator[] (S index)
{
return this->data[index];
}

int main()
{
vector<float,int> v1(10);
v1[1] = 5.5;
cout << v1[1];
getch();
return 0;
}




Ein Beispiel für Templates und Abstrakte Klassen:


#include <conio.h>

template <class S>
class vector
{
public:
virtual S getLength() = 0;

};

int main()
{
//vector<int> v1(); ->Fehlermeldung da abstrakt
getch();
return 0;
}



Ich hoffe das trifft deine Frage...

[Gnafoo]

Hm das ist eigentlich nicht das, was ich meine. Ich will
nicht die gesamte Klasse als Template, sondern nur diese
eine Funktion in der Klasse. :)

cu DerTod

[HajottV]

Original geschrieben von DerTod2k

[...]


invalid use of `virtual' in template declaration




Könnte es sein, daß Du die Methode nur anhand ihres Rückgabewertes zu überladen versuchst (was nicht geht), also daß im - von Dir ausgelassenen (...) in der blah-Deklaration kein T mehr benutzt wird? Die Fehlermeldungen des gcc gehen manchmal am Problem vorbei...

Probier mal Folgendes:


template<class T> virtual void bla(..., T** ptrPtrT) = 0;


Gruß

Jörg

[Gnafoo]

Es war wirklich kein T bei den Parametern, aber wenn ich es ändere bleibt gcc trotzdem dabei ..

Sieht jetzt so aus:

template<class T>
virtual void createEntity(T** ppEntity, std::string library, std::string entity) = 0;


gcc:

g++ -c engine.cc -I../ -I../../ -fPIC
In file included from ../core/engine.h:6,
from engine.cc:1:
../../interface/core.h:37: invalid use of `virtual' in template declaration of
`virtual void twilight::core::iScene::createEntity(T**,
std::basic_string<char, std::char_traits<char>, std::allocator<char> >,
std::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
make: *** [engine.o] Fehler 1

[Achill]

Warum möchtest du das machen - evtl. hilft hier ein Nullzeiger?

Ansonsten habe ich mich noch nicht damit beschäftigt, weil ich es noch nicht gebraucht habe.

Ein sehr gutes Buch zu Templates ist:

Modern C++ Design: Generic Programming and Design Patterns Applied, von Andrei Alexandrescu, Addison Wesley Verlag

Vieleicht findest du was, ist aber auf englisch.

[HajottV]

Original geschrieben von Der Tod


template<class T>
virtual void createEntity(T** ppEntity, std::string library, std::string entity) = 0;




Ahh! *Patsch* Ich glaube, das Problem liegt woanders: Es macht ja überhaupt keinen Sinn, eine virtuelle Templatemethode OHNE Body zu deklarieren. Wenn der Compiler zu der Methode eine konkrete Implementierung erzeugen möchte, dann kann er das nicht, weil die Methode ja "pure" ist. (Aus genau dem Grund müssen die Deklarationen von template-Methoden ja im Header stehen.)

Mach's am besten so... und überschreib die Methode dann.


template<class T>
virtual void createEntity(T** ppEntity, std::string library, std::string entity) {};


Gruß

Jörg

[RoKo]

Moooment mal:
Wenn ich mich recht entsinne, sind virtuelle Template Methoden laut ISO Standard nicht erlaubt.

[bendel]

Virtuelle Template-Funktionen können ja auch gar nicht funktionieren. Wie soll den der Compiler auch die VTable aufbauen? Es können ja templateartig beliebige Funktionnen entstehen. Und das ist ja zum Erzeugungszeitpunkt nicht bekannt.

[Gnafoo]

Hm ok :)
dann geh ich mal davon aus, dass es gar nicht geht.
Danke trotzdem.

cya

[Achill]

Ich muss nochmal fragen ... :)

Warum möchtest du das machen?

Vieleicht gibt es ja eine andere Möglichkeit zum lösen deines Problems - man kann dabei nur lernen ;)

[Gnafoo]

Ich hab halt ne Interface Klasse mit einer template-Funktion
für meine Engine gebraucht (ist sowieso nur zum Experimentieren :D).
Habe aber bereits eine andere Möglichkeit gefunden.
Die Frage habe ich aber vor allem auch deswegen gestellt, weil
ich sozusagen "drüber gestolpert" bin und mich jetzt interessiert
hat, ob sowas in C++ prinzipiell überhaupt möglich ist.

cu DerTod