在自定义向量类中调用了错误的构造函数

我是C++的新手，作为一个学习练习，我正在创建自己的简单向量类。

它似乎工作得很好，除了当我创建一个Vec对象试图使用
Vec(size_type n，const T&val=T(((构造函数，它希望使用模板化的构造函数，该构造函数应该使用两个迭代器/指针，并给我错误。

我相信我理解为什么会发生这种情况，但我想不出一种方法，在不改变类的使用方式的情况下，让它变得不那么模糊。我希望使用与std：：vector相同的方法。

如何调用正确的构造函数？std:：矢量如何避免这个问题？

Vec.h

//#includes: <algorithm> <cstddef> <memory>
template <class T> class Vec
{
public:
//typedefs for iterator, size_type....
//just used T* for iterator
    Vec() { create(); }
    Vec(const Vec& v) { create(v.begin(), v.end()); }
    explicit Vec(size_type n, const T& val = T()) { create(n, val); }
    template <class InputIt>
    Vec(InputIt first, InputIt last) { create(first, last); }
    ~Vec() { uncreate(); }
    T& operator[](size_type i) { return data[i]; }
    const T& operator[](size_type i) const { return data[i]; }
    Vec& operator=(const Vec&);
    //functions such as begin(), size(), etc...
private:
    iterator data;
    iterator avail;
    iterator limit;
    std::allocator<T> alloc;
    void create();
    void create(size_type, const T&);
    template <class InputIt>
    void create(InputIt first, InputIt last)
    {
        data = alloc.allocate(last - first);
        limit = avail = std::uninitialized_copy(first, last, data);
    }
    void uncreate();
    void grow();
    void unchecked_append(const T&);
};
template <class T>
Vec<T>& Vec<T>::operator=(const Vec& rhs)
{
    if (&rhs != this)
    {
        uncreate();
        create(rhs.begin(), rhs.end());
    }
    return *this;
}
template <class T> void Vec<T>::create()
{
    data = avail = limit = 0;
}
template <class T> void Vec<T>::create(size_type n, const T& val)
{
    data = alloc.allocate(n);
    limit = avail = data + n;
    std::uninitialized_fill(data, limit, val);
}
template <class T>
void Vec<T>::create(const_iterator i, const_iterator j)
{
    data = alloc.allocate(j - i);
    limit = avail = std::uninitialized_copy(i, j, data);
}
template <class T> void Vec<T>::uncreate()
{
    if (data)
    {
        iterator it = avail;
        while (it != data)
            alloc.destroy(--it);
        alloc.deallocate(data, limit - data);
    }
    data = limit = avail = 0;
}
//left out what I didn't think was relevant

除了我上面提到的情况外，它似乎运行良好。

main.cpp

#include "Vec.h"
main()
{
    Vec<int> v1(10, 100);
}

我收到错误：

||===编译：在Vec类中调试(编译器：GNU GCC编译器(===|c： \program files\codeblocks\mingw\bin\。。\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_uniinitialized.h||在'_ForwardIterator std:：uninitialized_copy(_InputIterator，_InputIt erator，_ForwardIt erator(的实例化中[其中_InputIterator=int；_Forward Iterator=int*]'：|F： \CBProjects\Accelerated C++\ Programming with Classes\Vec Class\Vec.h|58|必需自'void Vec:：create(InputIt，InputIt([with InputIt=int；T=int]'|F： \CBProjects\Accelerated C++\ Programming with Classes\Vec Class\Vec.h|24|必需自"Vec:：Vec(InputIt，InputIt([with InputIt=int；T=int]"|F： \CBProjects\Accelerated C++\ Programming with Classes\Vec Class\main.cpp|9|此处为必填项|c： \program files\codeblocks\mingw\bin\。。\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_uniinitialized.h|113|错误："struct-std:：iterator_traits"中没有名为"value_type"的类型|||===生成失败：1个错误，4个警告(0分钟，0秒(===|

这是我第一次在这里提问。我希望我问得恰当，并提供了足够的信息。如果我在这个过程中犯了错误，请告诉我，并感谢你能提供的任何帮助。

编辑：

对于任何想知道我最终做了什么的人。我更改了模板化的构造函数，这样它就不会被算术参数调用(因为它只适用于迭代器/指针(。

template <class InputIt>
Vec(InputIt first, InputIt last,
    typename std::enable_if<!std::is_arithmetic<InputIt>::value>::type* = 0) {create(first, last); }  

它看起来很好用，但实际上我对enable_if不是很熟悉，所以如果有人知道这种方法的任何危险，请告诉我。