#include <vector>

template <class Elem>
class SomeClass
{
public:
    vector<Elem> vec;
    SomeClass (const vector<Elem> &vec_): vec(vec_){}
};

int main (void)
{
    vector<int> vec;
    SomeClass<int> sc1(vec); // ок
    SomeClass sc2(vec); // не ок
}

L>#include <vector>

L>template <class Elem>
L>class SomeClass
L>{
L>public:
L>    vector<Elem> vec;
L>    SomeClass (const vector<Elem> &vec_): vec(vec_){}
L>};

L>int main (void)
L>{
L>    vector<int> vec;
L>    SomeClass<int> sc1(vec); // ок
L>    SomeClass sc2(vec); // не ок
L>}
L>

 vector<double> d_vec;
 vector<int> vec;
 SomeClass sc1(vec), sc2(d_vec); // уже интересно, типы с виду одинаковые
 sc1 = sc2; // А что тут делать?

class SomeClass
{
public:
        template<T>
    SomeClass() {}
};

class base {
     //interface goes here
     ....
};


template <class T>
class derived : public base {
//data memebers and implementation
....
};


typedef const base& MyClass;


template <class T>
base create_class(T ...) {
    derived<T> t;    
    ...
}


void main () {
     MyClass class = create_class(var);
}

class base {
     //interface goes here
     ....
};


template <class T>
class derived : public base {
//data memebers and implementation
....
};


typedef const base& MyClass;



//CORRECTED
template <class T>
derived<T> create_class(T ...) {
    derived<T> t;    
    ...
}


void main () {
     MyClass class_instance = create_class(var);
}

V>void main () {
V>     MyClass class_instance = create_class(var);
V>}
V>

int main()
{
  auto x = create_x(var);
}