Шаблоны template с ограниченными параметрами

template <class T>
class MyVec {
    std::vector<T> m_vec;
};

template<class T>
class MyVec
{
    static_assert(std::is_same<T, int>::value && std::is_same<T, MyClass1>::value, 
"only int and MyClass1");
};

#include <vector>
#include <iostream>
using namespace std;
 
class MyType
{
private:
    double p;
public:
    MyType(){p = 0;}
    MyType(double val){p = val;}
    MyType(const MyType & ptr)
    {
        p = ptr.p;
    }
    MyType operator+(double val)
    {
        return p + val;
    }
    MyType operator-(double val)
    {
        return p - val;
    }
    MyType operator/(double val)
    {
        return p / val;
    }
    MyType operator*(double val)
    {
        return p * val;
    }
};
 
class GybridContainer
{
private:
    vector<pair<int, MyType> > vec;
    typedef vector<pair<int, MyType> >::iterator iterator;
public:
    GybridContainer(){vec.clear();}
    void push_back(int val)
    {
        MyType p = 0;
        vec.push_back(make_pair(val, p));
    }
    void push_back(MyType val)
    {
        int p    = 0;
        vec.push_back(make_pair(p, val));
    }
    int atI(int i)
    {
        return vec.at(i).first;
    }
    MyType atT(int i)
    {
        return vec.at(i).second;
    }
};
 
int main()
{
    GybridContainer pContainer;
    for(int i = 0; i < 20; i++)
    {
        if(i%2)
            pContainer.push_back(i);
        else
            pContainer.push_back(100.0*i);
    }
    return 0;
}

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
    _ValueType;
 
      // concept requirements
      __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
        _RandomAccessIterator>)
      __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, _ValueType,
                  _ValueType>)
      __glibcxx_requires_valid_range(__first, __last);

      template<typename... _UElements, typename = typename
           std::enable_if<sizeof...(_UElements)
                  == sizeof...(_Elements)>::type>
        explicit
        tuple(_UElements&&... __elements)
    : _Inherited(std::forward<_UElements>(__elements)...) { }

template <class T>
class MyVec;
 
template <>
class MyVec<int>
{ std::vector<int> my_vec; }
 
template <>
class MyVec<MyClass>
{ std::vector<MyClass> my_vec; }