Call of overloaded is ambiguous при реализации своего алгоритма copy

Есть самописное подобие stl. Суть задачи - вектор пар (тоже самописные).

Проблема появилась при попытке создать вектор с парами при включении в пару std::string. Заругалось на неоднозначность:

ошибка: call of overloaded 'copy(vector<pair<std::__cxx11::basic_string<char>, int> >::iterator, vector<pair<std::__cxx11::basic_string<char>, int> >::iterator, pair<std::__cxx11::basic_string<char>, int>*&)' is ambiguous
         copy(begin(), end(), newMemory);
         ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~

Заменяю copy(begin(), ... на std::copy(begin(), ..., и все компилируется.

Реализация алгоритма copy скопирована справочника. Там заявлено:

The behavior of this function template is equivalent to

то есть

поведение шаблона функции эквивалентно коду, приведенному ниже

В итоге, не могу понять, что не так с алгоритмом copy, взятым из справочника. Почему он не переваривает std::string если заявлено, что его поведение эквивалентно std::copy?

#include <string>
#include <algorithm>
template<class T1, class T2>
class pair
{
public:
    pair() :
        first(T1()),
        second(T2())
    {
    }
    pair(T1 _first, T2 _second) :
        first(_first),
        second(_second)
    {
    }

    T1 first;
    T2 second;
};
template<class MyInputIterator, class MyOutputIterator>
MyOutputIterator copy(MyInputIterator first, MyInputIterator last, MyOutputIterator result)
{
    while (first != last) {
        *result = *first;
        ++result; ++first;
    }
    return result;
}
template<class T>
class vector
{
public:
    vector() : _data(nullptr), _size(0) {}
    void push_back(const T &val)
    {
        reserve(_size + 1);
        _data[_size] = val;
        _size += 1;
    }
    void reserve(size_t n)
    {
        if (n > _size)
        {
            T *_newData = new T[_size + 1];
            if (_data) 
            {
                copy(begin(), end(), _newData);  //<<< ругается здесь
                delete [] _data;
            }
            _data = _newData;
        }
    }
    T* begin() { return _data; }
    T* end() { return _data + _size; }
private:
    T *_data;
    size_t _size;
};
int main()
{
    vector<pair<std::string, int>> v;
    v.push_back(pair<std::string, int>("qwerty", 5));
    return 0;
}

P.S. Это что-то вроде тренировки на кошках (во избежание комментариев типа "зачем всё это надо, если есть stl").