C++ STL algobase.h

全部代码

#pragma once

#include <cstring>

#include "util.h"
#include "iterator.h"

namespace tinySTL {

	template<typename T>
	const T& max(const T& lhs, const T& rhs) {
		return lhs < rhs ? rhs : lhs;
	}

	template<typename T, typename Compare>
	const T& max(const T& lhs, const T& rhs, Compare cmp) {
		return cmp(lhs, rhs) ? rhs : lhs;
	}

	template<typename T>
	const T& min(const T& lhs, const T& rhs) {
		return rhs < lhs ? rhs : lhs;
	}

	template<typename T, typename Compare>
	const T& min(const T& lhs, const T& rhs, Compare cmp) {
		return cmp(rhs, lhs) ? rhs : lhs;
	}

	// 将两个迭代器所指对象对调
	template<typename Iter1, typename Iter2>
	void iter_swap(Iter1 lhs, Iter2 rhs) {
		tinySTL::swap(*lhs, *rhs);
	}

	// 将[first, last)区间内的元素拷贝到[result, result+(last-first))内
	
	// input_iterator_tag
	template<typename InputIter, typename OutputIter>
	OutputIter unchecked_copy_cat(InputIter first, InputIter last, OutputIter result,
		tinySTL::input_iterator_tag) {
		for (; first != last; ++first, ++result)
			*result = *first;
		return result;
	}

	// random_iterator_tag
	template<typename RandomIter, typename OutputIter>
	OutputIter unchecked_copy_cat(RandomIter first, RandomIter last, OutputIter result,
		tinySTL::random_access_iterator_tag) {
		for (auto n = last - first; n > 0; --n, ++first, ++result)
			*result = *first;
		return result;
	}

	template<typename InputIter, typename OutputIter>
	OutputIter unchecked_copy(InputIter first, InputIter last, OutputIter result) {
		return unchecked_copy_cat(first, last, result, iterator_category(first));
	}

	// 为trivially_copy_assignable类型提供特化版本
	template<typename Tp, typename Up>
	typename ::std::enable_if<
		::std::is_same<typename ::std::remove_const<Tp>::type, Up>::value &&
		::std::is_trivially_copy_assignable<Up>::value
		, Up*>::type
		unchecked_copy(Tp* first, Tp* last, Up* result) {
		const auto n = static_cast<size_t>(last - first);
		if (n != 0)
			std::memmove(result, first, n * sizeof(Up));
		return result + n;
	}

	template<typename InputIter, typename OutputIter>
	OutputIter copy(InputIter first, InputIter last, OutputIter result) {
		return unchecked_copy(first, last, result);
	}

	// 将[first, last)区间内的元素拷贝到[result - (last, first), result)内

	// copy_backward bidirectional_iterator_tag
	template<typename BidirIter1, typename BidirIter2>
	BidirIter2 unchecked_copy_backward_cat(Bidir