TemplateClass-Funktion mit Konstruktor-Parametern bestücken

Hi, wie kann ich das machen bzw ist es möglich?

template<class T> class Xyz
{
T *t;
void func(/*die konstruktor paras von Typ T*/)
{
t=new T(/*die konstruktor paras von Typ T*/);
}
};

template<class T> class Xyz 
{ 
   T *t; 
   void func(/*die konstruktor paras von Typ T*/) 
   { 
     t=new T(/*die konstruktor paras von Typ T*/); 
   } 
};

codetags sind net schlecht..

also am besten func so häufig überladen das alle überladenen Konstruktoren auch über func aufrufbar sind

DrGreenthumb

template<class T> class Xyz  
{  
   T *t;
   template<class Arg1>  
   void func(const Arg1& a)  
   {  
     t=new T(a);  
   }

   template<class Arg1, class Arg2>  
   void func(const Arg1& a,const Arg2& b)  
   {  
     t=new T(a, b);  
   }  

   // und so weiter :(
};

Muss man bei Bedarf erweitern, bessere Lösung gibt's AFAIK nicht.

phlox81

Hm, evtl. könnten typlisten helfen.
Kenn mich da allerdings nicht so genau aus...

Devil

static_caster

DrGreenthumb schrieb:

template<class T> class Xyz  
{  
   T *t;
   template<class Arg1>  
   void func(const Arg1& a)  
   {  
     t=new T(a);  
   }
   
   template<class Arg1, class Arg2>  
   void func(const Arg1& a,const Arg2& b)  
   {  
     t=new T(a, b);  
   }  

   // und so weiter :(
};

Muss man bei Bedarf erweitern, bessere Lösung gibt's AFAIK nicht.

find ich ziemlich gefährlich und unflexibel:

class HasPointer //gefährlich, weil:
{
int *changeme;
public:
HasPointer(int& i) : pt(&i) {}
};

template<class T> class EVIL
{
T* ttt;
public:
template<class arg> void func(const arg& aa)
{
ttt = new T(aa); //eig fehler ist: invalid conversion "const int*" to "int"
//durch das template erzeugter fehler: "no matching function for call"
}
};

//unflexibel, weil:

class A
{
/*...*/
public:
A(const int&, const float&, const char&);
};
class B
{
/*...*/
public:
B(const double&);

du kannst dieses problem allerdings dem anwender überlassen:

template<class T>class gousergo
{
T *t;
public:
void func(const T& tt)
{
t = new T(tt);
}
};
//mit HasPointer von oben:
void foo()
{
int itobechanged = 123;
gousergo<HasPointer> mygo;
mygo.func(HasPointer(itobechanged));
}

bei mir hats kompiliert & die richtige zahl ausgespuckt. wenns nit klappt, hab ich mich verschrieben

das mit dem pointer is nur n beispiel. wenn ich lange genug nachdenke, fallen mir sicher auch noch mehr ein

meine lösung find ich allerdings auch nicht super wegen des casts.

und ganz ansonsten, ändere das design. ich habs auch mal so versucht & es dann geändert, weil es nicht tragbar war (konnte keine kontruktoren mit gleicher variablenanzahl garantieren, glaub ich).

DrGreenthumb

Hm, ja da hast du Recht. Mit dem const ist das blöd.

static_caster schrieb:

du kannst dieses problem allerdings dem anwender überlassen:
void func(const T& tt)
{
t = new T(tt);
}
};

...
mygo.func(HasPointer(itobechanged));

Das finde ich als Alternative aber auch nicht gut, wegen dem temporären Objekt.

und ganz ansonsten, ändere das design.

Ich denke das ist das beste

ich habs auch mal so versucht & es dann geändert, weil es nicht tragbar war (konnte keine kontruktoren mit gleicher variablenanzahl garantieren, glaub ich).

Das wird ja durch die Überladungen gelöst, wobei es natürlich irgendwie schon ziemlich hässlich ist.