ich bin relativ unbegabt was tempaltes angeht habe hier noch wenig erfahrungen. Mir ist (wie ich denke) klar wie templates funktionieren.
Ich habe ein etwas spezielleres problem. Ich habe ein minimalbeispiel erstellt was aus meinem großen projekt eigentlich das wiederspiegelt woran ich hänge:

Ich habe 2 klassen D1, D2 die von einer Basisklasse Base erben.
Je nach "flag" instantiiere ich entweder D1 oder D2. Hier jetzt D1.

D1 hat einen templatebasierten member mtx der vom typ double ist.
D2 hat einen templatebasierten member mtx der vom typ int ist.

Dann habe ich eine normale (also nicht templatebasierte) Klasse ENV.
Ich möchte jetzt in ENV sozusagen templatespezialisierte Methoden
haben die je nach mtx-typ entweder copy<double> oder copy<int> aufrufen.
Das aber nur im übertragenen sinne - ich möchte nämlich NICHT!!! ENV in eine templatebasierte klasse umschreiben müssen. Das würde bei meinem großen Projekt totalen overkill bedeuten.

FRAGE: Habe ich eine andere Möglichkeit in ENV eine Art überladene Methode haben die je nach typ von mtx von base (b->mtx) entweder die eine methode anspringt oder die andere? Geht das?

Über eine geduldige und gut formulierte Antwort würde ich mich freuen

Danke.
Unten ist das Minimalbeispiel

#include <iostream>
#include <stdexcept>
#include <memory>
#include <stdexcept> 
template<class T> 
class Mtx
{
public:
        Mtx() { a = new T[10];}

        ~Mtx() { if (a) delete [] a;}

        T *a;
};

class Base
{
        public:
           virtual ~Base() {  };
           virtual void foo() = 0;
};

class D1 : public Base
{
        public:
                D1() { mtx = new Mtx<double>(); }
                ~D1() { delete mtx; }
                void foo() {     
                      std::cout << "Hallo D1" << std::endl;                          
                }

        private:
                Mtx<double>* mtx; 
};
class D2 : public Base
{
        public:
                D2() { mtx = new Mtx<int>(); }
                ~D2() { delete mtx; }

                void foo() {     

                }

        private:
                Mtx<int>* mtx; 

};

class ENV
{
        public: 
                void method_1(Base* b)
                {
                    copy(b);         
                }

                //!!! Ich möchte gerne hier an dieser stelle
                // 2 copy methoden haben die vom typ entweder double oder
                // int arrays kopieren. Je nach dem welchen typ das element mtx von 
                // der klasse D1 bzw. D2 hat. Geht das überhaupt?
                // So gehts auf jedenfall nicht:
                void copy(Base* b)
                {
                    int* copy_a = new int[10];
                    memcpy(copy_a,b->mtx->a,10*sizeof(int));    
                }
};

int main(int argc, char** argv)
{
        Base * base = NULL;
        ENV env;               

        if (true) base = new D1();
        else base = new D2();

        base->foo();
        env.method_1(base);           

        delete base;

        return 0;
}

Das einzige was gehen würde, allerdings ist es nicht so sauber und ich weiss nicht, ob es dir behilflich ist, wäre eine Art Visitor-Pattern anzuwenden.

struct visitor
{
  void operator ()(mtx<int> const& mtx) const
  {
    // ...
  }

  void operator ()(mtx<double> const& mtx) const
  {
    // ...
  }
};

class base
{
private:
  // Damit Nexus nichts rumzumeckern hat ...
  virtual void handle_visitor(visitor const& visitor) const;

public:
  void visit(visitor const& visitor) const;
};

class derived_01
  : public base
{
private:
  virtual void handle_visitor(visitor const& visitor) const
  {
    visitor(m_mtx);
  }

  mtx<int> m_mtx;
};

class derived_02
  : public base
{
private:
  virtual void handle_visitor(visitor const& visitor) const
  {
    visitor(m_mtx);
  }

  mtx<double> m_mtx;
};

int main()
{
  base* base = 0;

  if(/*condition*/)
  {
    base = new D1();
  }
  else
  {
    base = new D2();
  }

  visitor v;
  base->visit(v);

  delete base;

  return 0;
}

So kannst du zwar unterschiedlich reagieren, schränkst dich aber auf die Typen im visitor ein. Zudem kannst du nur im visitor auf die Unterschiede sinnvoll reagieren. Die unterschiedlichen Arrays zurückgeben, ist nur wieder sehr einschränkend und nochmals sehr unsauber.

Ich rate eher dazu, nochmals das Design an sich zu überdenken.

Grüssli

Was ich erreichen wollte/möchte:
* Ich möchte nun auf dem zur laufzeit erstellten mtx (Field_Base) (siehe main)
je nach instantiierter Klasse z.B. die Methode foo() aufrufen.
* In foo() wird jetzt je nach Admin-Template entweder D1 oder D2 angesprungen. (Hier D2).

Fragen:

1. *UNd in D2 würde ich jetzt gerne template-abhängig - also vom typ von mtx
   sachen machen. Z.B. hätte ich gern sowohl template-methoden also auch template-spezialisierungen (z.B. void bar2(Mtx<double> mtx) { ...})
   Geht das?

2. Wenn 1) nicht gehen sollte - wie kann ich es sauber hinbekommen? Im Moment hänge ich wirklich an einem Punkt an dem ich nicht weiterweiß. Je genauer die antwort desto mehr wird mir geholfen! Danke hier schonmal. Ich möchte eine saubere und am liebsten natürlihc mit geringstem Aufwand zu erbringende Lösung. Habe ich eine Chance?

Danke euch

#include <iostream>

class D1
{
    public:
        void bar() {
            std::cout << "D1::bar(): Eine Methode die auf nix zugreift und" 
                        " Sachen macht" << std::endl;      
        }
        void bar2() {
            std::cout << "D1::bar2(): weitere methode" << std::endl;       
        }
};

class D2
{
    public:
        void bar() {
            std::cout << "D2::bar(): Eine Methode die auf nix zugreift und" 
                        " Sachen macht" << std::endl;      
        }
        void bar2() {
            std::cout << "D1::bar2(): weitere methode" << std::endl; 
            // !!!!!!!! HIer will ich jetzt auf template abhängig auf mtx zugreifen -
            // also z.B. so - ich weiß aber nicht wie:      
            // Ich würde gerne einen template-abhängigen member haben so dass ich 
            // bar2() überladen könnte mit templat-spezialisierungen - also:
            // void bar2(Mtx<double> *mtx) {...} und void bar2(Mtx<int> *mtx)
            // KÖnnte ich in FieldD in der methode foo einfach env.bar2(this)
            // setzen? Aber ich kann ja hier dann so nicht template-abhängig
            // prüfen.
        }
};

class Admin_Base
{
    public:
        virtual void bar() = 0;
        virtual void bar2() = 0;      
};

template <class T_D>
class Admin : public Admin_Base
{
    public:
        void bar() {
            env.bar();
        }
        void bar2() {
            env.bar2();
        }
    private:    
        T_D env;   
};

template <class T>
class Mtx
{
    public:
        Mtx() {len = 9;}
        int len;  
};

class Field_Base
{
    public:
        virtual void foo(Admin_Base& env) = 0;      
};

class FieldD : public Field_Base
{
    public:

    void foo(Admin_Base& env) 
    {
        mtx = new Mtx<double>();
        std::cout << mtx->len << std::endl;
        env.bar2();
        delete mtx;
    }

    Mtx<double> *mtx;      
};

int main(int argc, char** argv)
{
#ifdef FLAG
        Admin<D1> myAdmin;
#else
        Admin<D2> myAdmin;
#endif  

        Field_Base      *mtx = NULL;

        if (true) mtx = new FieldD();

        mtx->foo(myAdmin);

        myAdmin.bar();

        return 0;
}

Ich könnte mir doch einen Basisklassen Poitner (Com_Base) erschaffen und dann eine templatebasierte ableitende klasse erstellten. In dieser Template-klasse halte ich einen Mtx<T> Pointer und diesen setze ich eben aus der FieldD::foo() Methode mit setcombase(). Dann kann ich doch
innherlb der D1 und D2 halt auf ein templateobjekt zugreifen (nach laufzeitpolymorphie) und so dann templatebedingt springen !?

Ist das unsauber oder unschön?

Gibt es eine bessere schönere idee?

#include <iostream>

template <class T>
class Mtx
{
    public:
        Mtx() {len = 9;}
        int len;  
};

class Com_Base
{
        public:    
                virtual void Comfoo() = 0;
                virtual void Combar(Mtx<double> *mtx) = 0;  
                virtual void Combar(Mtx<int> *mtx) = 0;
};

template <class T>
class Com : public Com_Base
{
        public:
            Com(Mtx<T> *mtx_) {mtx = mtx_;}
            void Comfoo();  
            void Combar(Mtx<double> *mtx){
                    std::cout << "Combar(Mtx<double>)"<< std::endl;
            }
            void Combar(Mtx<int> *mtx){
                    std::cout << "Combar(Mtx<int>)"<< std::endl;
            }

         Mtx<T> *mtx;
};
// template<>
// void Com<double>::Combar(Mtx<double>* mtx)
// {
//         
// }
// template<>
// void Com<int>::Combar(Mtx<int>* mtx)
// {
//         
// }
template<class T>
void Com<T>::Comfoo()
{

}

//////////////////////////
class D1
{
    public:
        void bar() {
            std::cout << "D1::bar(): Eine Methode die auf nix zugreift und" 
                        " Sachen macht" << std::endl;      
        }
        void bar2(Mtx<double>* mtx) {
            std::cout << "D1::bar2(): weitere methode" << std::endl;       
        }
        void setcombase(Mtx<double> *mtx) {
                std::cout << "D1::setcombase(Mtx<double>)" << std::endl;
             //combase = new Com<double>(mtx);       
        }
        Com_Base* combase;
};

class D2
{
    public:
        void bar() {
            std::cout << "D2::bar(): Eine Methode die auf nix zugreift und" 
                        " Sachen macht" << std::endl;      
        }
        void bar2(Mtx<double>* mtx) {
            std::cout << "D1::bar2(): weitere methode" << std::endl; 
            // !!!!!!!! HIer will ich jetzt auf template abhängig auf mtx zugreifen -
            combase->Combar(mtx);
        }
        void setcombase(Mtx<double> *mtx) {
                std::cout << "D2::setcombase(Mtx<double>)" << std::endl;
             combase = new Com<double>(mtx);       
        }
        void setcombase(Mtx<int> *mtx) {
                std::cout << "D2::setcombase(Mtx<int>)" << std::endl;
             combase = new Com<int>(mtx);       
        }
        Com_Base* combase;
};

class Admin_Base
{
    public:
        virtual void bar() = 0;
        virtual void bar2(Mtx<double>* mtx) = 0;   
        virtual void setcombase(Mtx<double>* mtx) = 0;
        virtual void setcombase(Mtx<int>* mtx) = 0;     
};

template <class T_D>
class Admin : public Admin_Base
{
    public:
        void bar() {
            env.bar();
        }
        void bar2(Mtx<double>* mtx) {
            env.bar2(mtx);
        }
        void setcombase(Mtx<double>* mtx) {
                env.setcombase(mtx);
        }
        void setcombase(Mtx<int>* mtx) {
                env.setcombase(mtx);
        }
    private:    
        T_D env;   
};

class Field_Base
{
    public:
        virtual void foo(Admin_Base& env) = 0;      
};

class FieldD : public Field_Base
{
    public:

    void foo(Admin_Base& env) 
    {
        mtx = new Mtx<double>();
        std::cout << mtx->len << std::endl;
        env.setcombase(mtx);
        env.bar2(mtx);
        delete mtx;
    }

    Mtx<double> *mtx;      
};

int main(int argc, char** argv)
{
#ifdef FLAG
        Admin<D1> myAdmin;
#else
        Admin<D2> myAdmin;
#endif  

        Field_Base      *mtx = NULL;

        if (true) mtx = new FieldD();

        mtx->foo(myAdmin);

        myAdmin.bar();

        return 0;
}

Google einfach mal nach friend... c++ ..

Danke