Как можно объявить класс, заранее не зная его тип template.

template <class type> class My {
    private:
        int n;
        double sum;
        type *al;
    public:
        My()
        {
            al = NULL;
        }
        ~My()
        {
            delete [] al;
        }
}

#include "My.h"
 
void main()
{
    int prec;
 
    /* тут из файла считывается значение prec */
 
/*  if(prec == 1)
    {
        My <float> Class;
    }
    else if(prec == 2)
    {
        My <double> Class;
    }               */
 
    /* потом идёт много кода с участием Class */
}

        MyAbstract *class;
        if(prec == 1)
        {
                class = new My<float>;
        }
        else if(prec == 2)
        {
                class = new My<double>;
        }

class abstractMy {
                virtual abstractMy()
                {
                }
                virtual ~abstractMy()
                {
                }
}

class abstractMy {
};
template <class type> class My : public abstractMy {
    private:
        type *al;
    public:
        void init()
        {
        }
};

abstractMy *Some;
switch(prec)
{
    case 1:
        {
            Some = new My <float>;
        }
        break;
    case 2:
        {
            Some = new My <double>;
        }
        break;
    default:
        {
            Some = new My <float>;
        }
}
Some.init(); // left of '.init' must have class/struct/union

MyAbstract *class;

Some->init();

typedef std::shared_ptr<abstractMy> base_ptr;
base_ptr Some;
switch(prec)
{
        case 1:
                {
                        Some = base_ptr(new My <float>());
                }
                break;
        case 2:
                {
                        Some = base_ptr(new My <double>());
                }
                break;
        default:
                {
                        Some = base_ptr(new My <float>());
                }
}
Some->init(); // left of '.init' must have class/struct/union

class abstractMy {
    public:
        abstractMy(){}; // virtual или нет, все равно не создается My от него
        ~abstractMy(){};
        virtual void Init() = 0; // virtual bool Init() = 0; или = false не получается.
};
 
template <class type> class My : public abstractMy {
    private:
        type *al;
    public:
        My()
        {
            al = NULL;
        }
        ~My()
        {
            delete [] al;
        }
        bool Init(int size)
        {
            /* */
            al = new type[size];
            return true;
            /* */
        }
}