template mit non specified template argument ???

Flow_cplus

Hi

hab ein kleines Problem:

Ich habe eine template class, mit ein paar template parametern:

template <class SignalType,class SignalProcessor>
class SomeNameWrapperClass 
{
...
};

So dieses template benuzte ich z.b so:

SomeNameWrapperClass<double,SomeProcessorType<double> >

So Im endeffect kann SignalType viele moeglich Typen schlucken, der Processor hingegen ist immer von einer templated basisklasse abgeleited, welche alles argument auch immer den Signaltype hat:

Ich wuerde das ganze prinzipell ca so haben(was aber nicht geht):

template <class SignalType,class SignalProcessorNonspecific>
class SomeNameWrapperClass 
{

private:
SignalProcessorNonspecific<SignalType> *m_processor;
...
};

Der processor ware z.B

template <class SignalType>
class BaseProcessor {...};

Und dann so instanziert:

SomeNameWrapperClass<double,BaseProcessor>  Instance1;

So dies geht ja aber nicht, da "BaseProcessor" ohne template argument ja nicht specific ist. Ich dachte das sollte so gehen, da ja in der Klasse alle nicht spezifischen Sachen spezifiert werden. D.h zum compile Zeitpunkt ware ja alles klar (oder wenn ein falscher type dem template gefuettert wird, dann sollte es ja einen kompiler error geben)

Frage nun: kann man so was irgendwie realisieren? Was mir an der ersten loesung nicht gefaellt, dass man als benutzer des templates den Singaltype, der beiden klassen zu eingen ist (wrapper und processor) zweimal fuettern muss, und den type wuerde ich gerne zwingend als identisch haben.

So falls irgendjemand verstanden hat was ich will, kann mir jemand ein paar tips geben, wie und ob man das machen kann?

Gruesse
Flow

Mathias

Die Templatedefinition ist keine Basisklasse für alle Ausprägungen des Templates. Mit anderen Worten die unterschiedlichen Ausprägungen eines Templates haben nicht automatisch eine gemeinsame Basisklasse und das ist auch sehr gut so...

Wenn du das brauchst... leite das Template doch von einer Basisklasse ab, dann kannst du dein zweites Template mit dieser Basisklasse instanziieren.

schokomann

Moin,

vielleicht habe ich es nicht ganz genau verstanden,
aber bei dieser Konstruktion musst Du nur einmal den
Typ reinstopfen. Vielleicht kommst Du ja damit zurecht.

Ich kenne eben deine Designvorstellungen nicht.
Den Defaultkonstruktor braucht man nicht mehr.

#include <iostream>

template < class T >
class BaseProcessor
{
public:
   BaseProcessor() 
   { 
      printf( "Baseprocessor\n");

   }

   BaseProcessor( const T& t) 
   { 
      printf( "Baseprocessor S. \n");
      m_type = t;
   }

private:
   T m_type;
};

template < class T >
class SignalType 
{
public:
   SignalType( const T& t) : m_Type( t )
   {
      m_Base = BaseProcessor< T >(t);
   }

   SignalType() 
   { 
      printf( "Signaltype\n");
   }

   BaseProcessor< T >& getBase(){ return m_Base; }
private:
   T m_Type;
   BaseProcessor< T > m_Base;
};

int main()
{
   double x = 1.0;
   SignalType< double > s1(x);
   SignalType< double > s2;

   BaseProcessor<double>& b1 = s1.getBase();

   return 1;
}

rapso

statt

Flow_cplus schrieb:

SomeNameWrapperClass<double,BaseProcessor>  Instance1;

lieber

SomeNameWrapperClass<BaseProcessor<double> >  Instance1;

dann duerfte es keine probleme geben.

HumeSikkins

Hallo,
also ich bezweifle, dass ich das Problem verstanden habe, aber wären Template-Template-Parameter hier nicht das Naheliegenste?

template <class T>
struct BaseProcessor {
   // ...
};

// ProcType muss ein Template sein, dass genau einen Parameter erwartet
template <class SigType, template <class> class ProcType>
struct SomeNameWrapperClass {
  typedef ProcType<SigType> BaseType;
};

int main() {
SomeNameWrapperClass<double, BaseProcessor> x;

}

Flow_cplus

HumeSikkins schrieb:

Hallo,
also ich bezweifle, dass ich das Problem verstanden habe, aber wären Template-Template-Parameter hier nicht das Naheliegenste?

template <class T>
struct BaseProcessor {
   // ...
};

// ProcType muss ein Template sein, dass genau einen Parameter erwartet
template <class SigType, template <class> class ProcType>
struct SomeNameWrapperClass {
  typedef ProcType<SigType> BaseType;
};

int main() {
SomeNameWrapperClass<double, BaseProcessor> x;

}

Dankesehr fuer alle antworten, letzteres is genau was ich suche, dankesehr. Hatte etwas im templatebuch A.W. geblaettert, aber das ist mir nicht sofort entgegengesprungen!

Gruesse