template <typename Inlay_Type>
class xy
{
   // Inhalt der Template Klasse
};

In den Inlay_Type werden sowohl Standard-Typen(int, double etc. hinterlegt). Aber auch eigene Datentypen. Sowohl auf Zeiger- als auch auf Nicht-Zeiger-Basis.

Das Problem was sich mir im Moment stellt ist folgendes:
Ich setze 'Inlay_Type' typename auf 'meineEigeneKlasse*'. Was kein Problem ist. Allerdings ist es nötig innerhalb des Templates neue Objecte von 'meineEigeneKlasse' zu erstellen. Dafür habe ich ein Standardobject 'initObj' welches eine 'meineEigeneKlasse'-Object beinhaltet (mit Standard-einstellungen).

Ich will dann innerhalb des Templates ein neues Object mit dem Inhalt des 'initObj' erzeugen.

Inlay_Type t = new Inlay_Type(*initObj);

// was natürlich ausgeschrieben heißt :
meineEigeneKlasse* t = new meineEigeneKlasse*();

Meine Frage ist nun ist es möglich das ich ein neues Object im Template erzeuge ohne:

- Ohne das ich eine Copy-C'tor alle meineEigeneKlasse(meineEigeneKlasse*) verwende der mir ein neues Obj erstellt
- Ohne das ich den Oerator '=' von 'meineEigeneKlasse' überschreibe das dieser mir das AlteObj in ein neues legt
- Ohne das ich einen zweiten Template-Parameter einführe.
- Ohne das ich den ersten Template-Parameter ohne '*' übergebe und den Stern halt nur da hinzufüge wo ich ihn brauche.

Idealer weise wär es natürlich wenn man beim 'typename' einfach das * wegzaubern könnte. Aber das funzt ja net soweit ich weis.

Vielen Dank für alle Anregungen, und einen schönen start ins Wochende...

Gruß Ollow

Idealer weise wär es natürlich wenn man beim 'typename' einfach das * wegzaubern könnte. Aber das funzt ja net soweit ich weis.

Gewissermaßen doch: Du kannst eine Spezialisierung für sämtliche Pointertypen schreiben. Ungefähr so:

template <typename T> class foo
{
public:
  void A()
  {
    cout<<"Gleich für alle Typen"<<endl;
  }
  void B()
  {
    cout<<"Speziell für Nicht-Pointer"<<endl;
  }
};

template <typename T> class foo<T*> : public foo<T>
{
public:
  void B()
  {
    cout<<"Speziell für Pointer"<<endl;
  }
};

int main()
{
  foo<int> bar;
  foo<int*> pbar;
  bar.A(); bar.B();
  pbar.A(); pbar.B();
}

Ich hoffe ich habe dich richtig verstanden, dass es dies ist, was du willst.

Hmm, ja diese Form der Spezialisierung habe ich bereits. Dennoch stoße ich leider innerhalb des Templates auf das geschilderte Problem.

Um bei deinen Beispiel zu bleiben

template <typename T> class foo<T*> : public foo<T>
{
public:
  void B()
  {
    cout<<"Speziell für Pointer"<<endl;
    T newObj = new T(*initObj); // <-- hier dann nach wie vor das Probelm
  }
};

An obiger Stelle habe ich dann das Problem, wenn ich ein neues Object des Typen
erstellen will. Denn im Klartext habe ich ja z.B. im Quellcode stehen

int* t = new int*(*initObj);

Womit ja eine 'int**' erhalte. Da ich ja nicht weiß was für einen Typen ich in das Template bekomme, müsste ich ja über 'typinfo' und 'typeid(T).name()' abfragen welchen Type ich habe damit ich in einer z.B. einer If-Abfrage welchen Type er nehmen soll etwa so in der Art..

template <typename T> class foo<T*> : public foo<T>
{
public:
  void B()
  {
    cout<<"Speziell für Pointer"<<endl;
    wxString typname = typeid(T).name();
    if (typename.IsSameAs(_T("int*"))) 
    {
        T newObj = new int(*initObj);
    }
    else if (typename.IsSameAs(_T("eigeneKlasse*"))) 
         {
             T newObj = new eigeneKlasse(*initObj);
         }
   // usw. für andere Typen
  }
};

Wäre aber eine unschöne Lösung meiner Meinung nach. Darum meine Hoffnung das es vielleicht doch eine Möglichkeit gegeben hätte beim 'typename' einfach das '*' wegzubekommen. Naja werde mal noch ein wenig in den MSDN-Seiten suchen. Ansonsten muss ich mir wohl doch überlegen den Typen ohne den *-Operator zu übergeben.

Aber vielen Dank für die Antwort...
Mfg

typedef remove_pointer< int* >::type my_int;
typedef remove_pointer< int >::type my_int2;

my_int und my_int2 sind jetzt die gleichen Typen, nämlich ganz normale Integer.

Bekomm jetzt zwar den C1189 - Error. Aber hab jetzt mal einen Ansatzpunkt. Da suchen ma mal was Google und das Forum dazu ausspuckt.

Erstmal besten Dank..

typedef typename remove_pointer<T*>::type my_type;

Sowas selbst zu bauen ist aber auch relativ einfach:

template <typename T>
struct remove_pointer
{
	typedef T type;
};

template <typename T>
struct remove_pointer<T*>
{
	typedef T type;
};

(ungetestet, sollte aber so funzen)

Du musst hier natürlich auch typename verwenden. VC++ treibt da leider ziemlich krumme Dinge mit typename.

Naja, innerhalb eines Templates muss dass typename da hin, ansonsten natürlich nicht.

314159265358979 schrieb:

Du musst hier natürlich auch typename verwenden. VC++ treibt da leider ziemlich krumme Dinge mit typename.

Naja, innerhalb eines Templates muss dass typename da hin, ansonsten natürlich nicht.

Jo, klar

template <typename T> class foo<T*> : public foo<T>
{
public:
  void B()
  {
    cout<<"Speziell für Pointer"<<endl;
    wxString typname = typeid(T).name();
    if (typename.IsSameAs(_T("int*"))) 
    {
        T newObj = new int(*initObj);
    }
    else if (typename.IsSameAs(_T("eigeneKlasse*"))) 
         {
             T newObj = new eigeneKlasse(*initObj);
         }
   // usw. für andere Typen
  }
};

Wäre aber eine unschöne Lösung meiner Meinung nach. Darum meine Hoffnung das es vielleicht doch eine Möglichkeit gegeben hätte beim 'typename' einfach das '*' wegzubekommen.

Verstehe gerade das Problem nicht. In der Spezialisierung "T*" steht T ja nicht mehr für den Zeiger Typ ("eigeneKlasse*"), sondern nur mehr für den Typ ("eigeneKlasse").
Demzufolge muss/kann der Code auch so aussehen:

template <typename T> class foo<T*> : public foo<T>
{
public:
  void B()
  {
    cout<<"Speziell für Pointer"<<endl;

    T* newObj = new T(*initObj);
  }
};

@ hustbaer:
Jap aber nur solange keiner versucht das Template mit einen 'eigeneKlasse*' zu füttern.

Aber mit den dem 'remove_pointer' funktionen klappt das ja jetzt einwandfrei.

Besten Dank an alle

@ hustbaer:
Jap aber nur solange keiner versucht das Template mit einen 'eigeneKlasse*' zu füttern.

Was wäre denn dann das Problem?

Ollow_AM schrieb:

An obiger Stelle habe ich dann das Problem, wenn ich ein neues Object des Typen
erstellen will. Denn im Klartext habe ich ja z.B. im Quellcode stehen

int* t = new int*(*initObj);

Hast du nicht. Wenn du foo<int*> instantiierst, greift die Spezialisierung foo<T*> und T ist int, nicht int*. Der code wird also zu

int t = new int(*initObj);

myTemplateClass<int> a;
// bzw
myTemplateClass<int*> b;

aufrufe erkennt er das das eine ein 'Zeigertype' ist geht direkt auf die Speziealisierung. Wenn ich das richtig verstehe ist das "ähnlich" wie bei Funktionen mit verschiednen Signaturen die ja ebenfalls unterschieden werden.

Hmm, dann werd ich mir das nochmal durch den Kopf gehen lassen. Wie ich es machen werde.

Mit dem

template <typename T> 
struct rm_ptr
{
	typedef T type;
};
template <typename T>
struct rm_ptr<T*>
{
	typedef T type;
};

klappt nämlich alles einwandfrei. Aber werd das ganze mal überdenken, auf welche Art und Weise ich es lösen werde.
Mfg

Mit dem

template <typename T> 
struct rm_ptr
{
	typedef T type;
};
template <typename T>
struct rm_ptr<T*>
{
	typedef T type;
};

klappt nämlich alles einwandfrei.

Weil es genau das selbe macht

"Man sieht den Wald vor lauter Bäumen nicht.." kann ich da nur sagen..