C++ 在运行时有条件地实例化模板

我有一个模板类

template <class T> 
class myClass
{
    public:
        /* functions */
    private:
        typename T::Indices myIndices;  
};

模板
类myClass
{
公众：
/*功能*/
私人：
typename T：：索引myindex；
};

现在在我的主代码中，我想根据条件实例化模板类。比如：

myFunc( int operation)
{
    switch (operation) {
        case 0:
            // Instantiate myClass with <A> 
            auto_ptr < myClass <A> > ptr = new myClass<A> ();
        case 1:
            // Instantiate myClass with <B> 
            auto_ptr < myClass <B> > ptr = new myClass<B> ();
        case 2:
            // Instantiate myClass with <C> 
        ....
    }
    // Use ptr here..
}

myFunc（整数运算）
{
开关（操作）{
案例0：
//使用
auto_ptrptr=newmyclass（）；
案例1：
//使用
auto_ptrptr=newmyclass（）；
案例2：
//使用
....
}
//在这里使用ptr。。
}

现在，这种方法的问题是，

auto_ptr

将在

开关{}

的末尾消失。 我不能在函数的开头声明它，因为我不知道将要实例化的类型

---

我知道我正试图在编译时实现运行时功能（使用模板），但仍然想知道是否有更好的方法来实现这一点。

您可以为

myClass

引入一个公共基，并将其用作

auto\u ptr

的参数。只是别忘了声明common base的析构函数为virtual。

应该可以做到这一点

myFunc( int operation)
{
    boost::variant< myclass<A>, myclass<B> > obj;
    switch (operation) {
        case 0:
            // Instantiate myClass with <A> 
            obj = myClass<A> ();
        case 1:
            // Instantiate myClass with <B> 
            obj = myClass<B> ();
        case 2:
            // Instantiate myClass with <C> 
        ....
    }
    // Use object here..
}

myFunc（int操作）
{
boost:：variant创建基类

class Base {     
  protected:
      virtual ~Base() {}
      //... functions
};

template <class T> class myClass : Base { 
  //...
};

myFunc( int operation){ 
   shared_ptr < Base >  ptr;

   switch (operation) {        
     case 0:            
          // Instantiate myClass with <A>             
          ptr.reset ( new myClass<A> () );        
     case 1:            
          // Instantiate myClass with <B>             
          ptr.reset ( new myClass<B> () ) ;        
      case 2:            
           // Instantiate myClass with <C>         ....    
     }    
     // Use ptr here..
}

类基{
受保护的：
虚拟~Base（）{}
//…功能
};
模板类myClass:基{
//...
};
myFunc（int运算）{
共享ptrptr；
开关（操作）{
案例0：
//使用
ptr.reset（新的myClass（））；
案例1：
//使用
ptr.reset（新的myClass（））；
案例2：
//用…实例化myClass。。。。
}    
//在这里使用ptr。。
}
低技术解决方案。使用具有所需范围的常规指针。
您可以添加一级间接寻址以获得所需内容。您可以使用虚拟方法避免基类和执行任何其他特殊操作

例如：

template <class T> 
class MyClass
{
    public:
        /* functions */
    private:
        typename T::Indices myIndices;  
};

template<typename T>
static void doit()
{
    MyClass<T> t;
    // Use t here.
}

void myfunc(int op)
{
    switch (op) {
        case 0: return doit<A>();
        case 1: return doit<B>();
        // ...
     }
 }

模板
类MyClass
{
公众：
/*功能*/
私人：
typename T：：索引myindex；
};
模板
静态void doit（）
{
MYT类；
//在这里使用t。
}
void myfunc（整数运算）
{
开关（op）{
案例0：返回doit（）；
案例1：返回doit（）；
// ...
}
}
这里的问题是“取消装箱”我猜需要使用变量中的类。您似乎有一个术语问题。您实例化一个类模板来创建一个类。您随后可以创建该类型的对象。在给定的示例中，您希望实例化
myClass
两次，参数为a和B，但创建一个对象。