Von spezialisierter template-Klasse erben

mortified_penguin

Hallo,

ich versuche grade eine spezialisierte template-Klasse als Basisklasse für die "allgemeine" template-Klasse zu verwenden:

template <typename T1, typename T2>
class A: public A<int>
{
      void bawk() {}
};

template <>
class A<int>
{
      virtual void bawk();
};

Allerdings bekomme ich da einige Kompilierfehler:

error: wrong number of template arguments (1, should be 2)

Ich gehe mal davon aus dass man irgendeine ausgefallene forward-deklaration braucht, komm aber gerade nicht drauf wie genau die aussehen muss.

Danke schonmal im Voraus!

dot

Das Klassentemplate A hat zwei Parameter, du kannst also nicht einfach A<int> schreiben, da fehlt ein Parameter. Was genau bezweckst du denn damit!?

mortified_penguin

Mir ist da ein kleiner Fehler beim Beispiel erstellen unterlaufen…

template <typename T1, typename... Ts> class A;

template <>
class A<int>
{
      virtual void bawk();
};

template <typename T1, typename... Ts>
class A: public A<int>
{
      void bawk() {}
};

So war es gemeint, funktioniert auch mit der forward-Deklaration.

dot

Gut wenn es funktioniert, auch wenn mir noch immer nicht klar ist, wieso A von A<int> erben muss bzw. wieso das, wovon A erbt, ein template sein muss. Ich nehme einfach mal an, dass du irgendeinen Grund dafür haben wirst!?
Ansonsten, wieso nicht einfach so:

class IA
{ 
    virtual void bawk() = 0;
}; 

template <typename T1, typename... Ts> 
class A: public IA
{ 
  void bawk() {} 
};

mortified_penguin

Konkret ging es um folgendes:
Ich habe eine Templateklasse die eine csv-Datei einliest. Dabei werden als Templateparameter die Datentypen der jeweiligen Spalten angegeben. Wenn nur std::string angegeben wird, werden die Zeilen "roh" als String zurückgeliefert; im ersten Fall als Tupel mit den entsprechenden Datentypen.
Die Templateklasse mit dem Tupel verhält sich im Prinzip genauso wie die die ein String zurückliefert, nur wird noch der rohe String in ein std::tuple "umgewandelt".

Vorher hatte ich beide Klassen getrennt von einer Basisklasse erben lassen, was ich aber relativ hässlich fand.

Sone

Schöner geschrieben, ohne vorwärts-Deklaration:

template <typename T1, typename... Ts> 
class A: public A<int> 
{ 
      void bawk() {} 
};

template <> 
class A<int> 
{ 
      virtual void bawk(); 
};

nur wird noch der rohe String in ein std::tuple "umgewandelt".

Das ist ineffizient. Zuerst die Zeile einlesen und dann formatiert alles extrahieren?
Was spricht dagegen einen Parser zu bauen der direkt extrahiert?