底层算法
template <class T1, class T2>
inline bool equal(T1 first1, T1 last1, T2 first2)
{
for (; first1 != last1; first1++, first2++)
{
if (*first1 != *first2)
{
return false;
}
}
return true;
}
template <class T1, class T2, class T3>
inline bool equal(T1 first1, T2 last1, T2 first2, T3 binary_pred)
{
for (; first1 != last1; first1++, first2++)
{
if (binary_pred(*first1, *first2) == false)
{
return false;
}
}
return true;
}
template <class T1, class T2>
void fill(T1 first, T1 last, const T2& value)
{
for (; first != last; first++)
{
*first = value;
}
}
template <class T1, class T2, class T3>
T1 fill_n(T1 first, T2 n, const T3& value)
{
for (; n > 0; n--, first++)
{
*first = value;
}
return first;
}
template <class T1, class T2>
inline void iter_swap(T1 a, T2 b)
{
return __iter_swap(a, b, value_type_t<T1>());
}
template <class T1, class T2, class T3>
inline void __iter_swap(T1 a, T2 b, T3)
{
T3 temp = *a;
*a = *b;
*b = temp;
}
template <class T1, class T2>
bool lexicographical_compare(T1 first1, T1 last1, T2 first2, T2 last2)
{
for (; first1 != last1 && first2 != last2; ++first1, ++first2)
{
if (*first1 < *first2)
{
return true;
}
else if (*first1 > *first2)
{
return false;
}
}
return first1 == last1 && first2 != last2;
}
template <class T>
inline const T& max(const T& a, const T& b)
{
return a < b ? b : a;
}
template <class T1, class T2>
inline const T1& max(const T1& a, const T1& b, T2 comp)
{
return comp(b, a) ? b : a;
}
template <class T>
inline const T& min(const T& a, const T& b)
{
return a > b ? b : a;
}
template <class T1, class T2>
inline const T1& min(const T1& a, const T1& b, T2 comp)
{
return comp(b, a) ? b : a;
}
template <class T1, class T2, class C>
bool lexicographical_compare(T1 first1, T1 last1, T2 first2, T2 last2, C comp)
{
for (; first1 != last1 && first2 != last2; first1++, first2++)
{
if (comp(*first1, *first2) == true)
{
return true;
}
else if (comp(*first2, *first1) == true)
{
return false;
}
}
return first1 == last1 && first2 == last2;
}
inline bool lexicographical_compare(const unsigned char* first1, const unsigned char* last1,
const unsigned char* first2, const unsigned char* last2)
{
const size_t len1 = last1 - first1;
const size_t len2 = last2 - first2;
const int res = memcmp(first1, first2, min(len1, len2));
return res != 0 ? res < 0 : len1 < len2;
}
template <class T1, class T2>
pair<T1, T2> mismatch(T1 first1, T1 last1, T2 first2, T2 last2)
{
while (first1 != last1 && (*first1 == *first2))
{
first1++;
first2++;
}
return pair<T1, T2>(*first1, *first2);
}
template <class T1, class T2, class T3>
pair<T1, T2> mismatch(T1 first1, T1 last1, T2 first2, T2 last2, T3 cmp)
{
while (first1 != last1 && cmp(*first1 ,*first2) == true)
{
first1++;
first2++;
}
return pair<T1, T2>(*first1, *first2);
}
template <class T>
inline void swap(T& a, T& b)
{
T cp = a;
a = b;
b = cp;
}
template <class T1, class T2>
class __copy_dispatch
{
T2 operator()(T1 first, T1 last, T2 result)
{
return __copy(first , last, result, iterator_category_t<T1>());
}
};
template <class T>
class __copy_dispatch<T*, T*>
{
T* operator()(T* first, T* last, T* result)
{
using t = typename _type_traits<T>::has_trival_assignment_operator;
return __copy_t(first, last, result, t());
}
};
template <class T>
class __copy_dispatch<const T*, T*>
{
T* operator()(const T* first, const T* last, T* result)
{
using t = typename _type_traits<T>::has_trival_assignment_operator;
return __copy_t(first, last, result,t());
}
};
template <class T, class R>
inline R copy(T first, T last, R result)
{
return __copy_dispatch<T, R>()(first, last, result);
}
inline char* copy(const char* first, const char* last, char* result)
{
memmove(result, first, last - first);
return result + (last - first);
}
template<class T, class R>
inline R __copy(T first, T last, R result, input_iterator_tag)
{
for (; first != last; ++first, ++result)
{
*result = *first;
}
return result;
}
template <class T, class R>
inline R __copy(T first, T last, R result, random_access_iterator_tag)
{
return __copy_d(first, last, result, difference_type_t<T>());
}
template <class T, class R, class D>
inline R __copy_d(T first, T last, R result, D)
{
for (D n = last - first; n > 0; n--, ++first, ++result)
{
*result = *first;
}
return result;
}
template <class T>
inline T* __copy_t(const T* first, const T* last, T* result, _true_type)
{
memove(result, first, sizeof(T) * (last - first));
return result + (last - first);
}
template <class T>
inline T* __copy(const T* first, const T* last, T* result, _false_type)
{
return __copy_d(first, last, result, ptrdiff_t());
}
template <class T1, class T2, class D>
inline T2 __copy_backward(T1 first, T1 last, T2 result, bidirectional_iterator_tag, D)
{
while (first != last)
{
--result;
--last;
*result = *last;
}
return result;
}
template <class T1, class T2, class D>
inline T2 __copy_backward(T1 first, T1 last, T2 result, random_access_iterator_tag, D)
{
for (D n = last - first; n > 0; n--)
{
--result;
--last;
*result = *last;
}
return result;
}
template <class T1, class T2, class B>
class __copy_backward_dispatch
{
T2 operator()(T1 first, T1 last, T2 result)
{
return __copy_backward(first, last, result, iterator_category_t<T1>(), difference_type_t<T1>());
}
};
template <class T>
class __copy_backward_dispatch<T *, T *, _true_type>
{
public:
T *operator()(const T *first, const T *last, T *result)
{
const ptrdiff_t n = last - first;
memmove(result - n, first, sizeof(T) * n);
return result - n;
}
};
template<class T>
class __copy_backward_dispatch<const T*, T* , _true_type>
{
public:
T *operator()(const T* first, const T* last, T* result)
{
return __copy_backward_dispatch<T*, T*,_true_type>()(first, last, result);
}
};
template<class T1, class T2>
inline T2 copy_backward(T1 first, T1 last, T2 result)
{
using trival = typename _type_traits<
value_type_t<T2>>::has_trivial_assignment_operator;
return __copy_backward_dispatch<T1, T2,trival>()(first, last, result);
}