Как можно изменить параметр шаблона (template)?

class abstract
{
public:
    virtual int method() = 0; // Допустим
};
 
class A:
    public abstract
{
    int number_int; 
public:
    A() {}
    int method()
    {
        return -1; // Допустим
    }
 
};
 
class B:
    public abstract
{
    float number_float = 5.5; // Допустим
public:
    B() {}
    int method()
    {
        return (number_float + 1) / 2;
    }
};
 
template < class T >
class general
{
    float number_general;
    T object;
public:
    general(int a) : object()
    {
        number_general = a;
    }
    int sum()
    {
        number_general += object.method();
        return number_general;
    }
};
 
int main()
{
    int num = 0;
    cin >> num;
    switch (num)
    {
    case 1: general<A> new_class(5); break; // 1
    case 2: general<B> new_class(5); break; // 2
    default:
        break;
    }
    cout << new_class.sum() << endl;
    system("pause");
    return 0;
}

switch (num)
    {
    case 1: new_class  = new A(); break; // 1
    case 2: new_class  = new B(); break; // 2
    default:
        break;
    }
general<*new_class> newnew_class(5);

template <typename T>
int work(general<T>& gnr)
{
    return gnr.sum();
}
 
int main()
{
    int num = 0;
    cin >> num;
    switch (num)
    {
    case 1:
    {
        general<A> new_class(5);
        cout << work(new_class) << endl;
        break;
    }
    case 2:
    {
        general<B> new_class(5);
        cout << work(new_class) << endl;
        break;
    }
    default:
        break;
    }
}

#include <iostream>
 
class T_abstract
{
public:
    virtual int method() = 0; 
};
 
class A:
    public T_abstract
{
    int number_int; 
public:
    A() {}
    int method()
    {
        std::cout   <<  'A'
                    <<  std::endl;
        return -1; 
    }
 
};
 
class B:
    public T_abstract
{
    float number_float = 5.5; 
public:
    B() {}
    int method()
    {
        std::cout   <<  'B'
                    <<  std::endl;
 
        return (number_float + 1) / 2;
    }
};
 
template < class T >
class T_general
{
    float number_general;
    T object;
public:
    T_general(int a) : object()
    {
        number_general = a;
    }
    int sum()
    {
        number_general += object.method();
        return number_general;
    }
};
 
int main()
{
    char    let     =   0;
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  "let = ";
        std::cin    >>  let;
 
        std::cout   <<  (
                            let     ==  'a'
                                ?   T_general<A>(5).sum()
                                :   T_general<B>(5).sum()
                        ) 
        
                    << std::endl;
    }//for
}

#include <iostream>
 
class A  // наследоваться от интерфейса не нужно
{
    int number_int; 
public:
    int method()const { return -1; }
};
 
class B
{
    float number_float = 5.5; 
public:
    int method()const { return (number_float + 1) / 2; }
};
 
 
// времени компиляции 
// вычисляем максимальный размер
// указанных типов
template<class A, class B> class max_size
{
    static const size_t sizeA = sizeof(A);
    static const size_t sizeB = sizeof(B);
public:
    static const size_t size = sizeA > sizeB ? sizeA : sizeB;
};
 
 
// не шаблонный!
class general
{
    // паттерн type erasure
    // суть в том, что есть не шаблонный интерфейс
    
    struct ihelper
    {
        virtual ~ihelper(){}
        virtual int sum() = 0;
    };
    
    
    // и шаблонный наследник
    // дергая не шаблонный интерфейс
    // мы приводим в действие функции шаблоно-наследника
    template <class T>
    struct helper : ihelper
    {
        helper(const int a)
            : number_general(a)
        {}
        
        virtual int sum() 
        {
            number_general += object.method();
            return number_general;
        }
        
        float number_general;
        T object;
    };
    
    
    // теперь резервируем буфер под будущего наследника
    // для этого рассчитываем оптимальный размер памяти
    // который может понадобится для его хранения
    enum { size = max_size<helper<A>, helper<B> >::size };
 
    // в качесте этого буфера
    // будем использовать обычный массив
    char type_erasure[ size ];
    
public:
 
       
    // данная функция порождает нужного нам наследника
    // аллоцируя его в нашем буфере
    template<class T> void make(const int a)
    {
        // убедимся, что наш массив достаточно большой
        // что бы вместить в себя наследника
        static_assert(
            sizeof(helper<T>) <= size,
            "ERROR: size helper too big"
        );
        
        // сообщаем, что хотим создать объект
        // не в куче, а в указанном хранилище
        new (type_erasure) helper<T>(a);
    }    
    
    
    // подсчитывает сумму
    int sum()
    {
        // на самом деле она лишь делегирует эту задачу наследнику
        // который сделает для нас всю грязную работу
        
        // но для этого нужно сначала извлечь наследника из нашего буфера
        // в рантайме мы не знаем его точного типа
        // но мы знаем про его не шаблонный интерфейс
        auto* help = reinterpret_cast<ihelper*>(type_erasure);
        
        //и через этот интерфейс можем привести наследника в действие
        return help->sum();
    }
 
    // теперь нам нужен диструктор
    // что бы корректно освободить все захваченные наследником ресурсы
    ~general()
    {
        // для этого извлекаем наследника
        // через его интерфейс
        auto* help = reinterpret_cast<ihelper*>(type_erasure);
        
        // и явным образом дергаем его виртуальный диструктор
        // так как диструктор виртуальный
        // то это приведет к запуску диструктора наследника
        // и тот корректно почистит все за собой
        help->~ihelper();
    }
 
    
};
 
 
// пример использованеия паттерна:
void example_pattern(const int num)
{
    // больше не шаблонный
    general example;
    
    switch (num)
    {
        // теперь в зависимости от 
        // захватываем ресурс: A или B указав стартовые параметры
        case 1: example.make<A>(5); break; 
        case 2: example.make<B>(5); break; 
    }
    
    // и теперь спокойно подсчитываем сумму
    std::cout << "результат для num = "<< num 
        << " : " << example.sum() << "\n";
}
 
int main()
{
    std::cout
        <<"добрый вечер, AAANDREW\n"
        <<"вам может помочь паттерн 'type erasure'\n";
    
    
    example_pattern(1);
    example_pattern(2);
    
}