<algorithm> std::find(), std::unique()

std::find()

template<typename InputIterator, typename Tp>
inline InputIterator find(InputIterator first, InputIterator last, const Tp val)
{
	while(first != last && !(*first == val))
    	++first;
    return first;
}

while문은 first == last 또는 *first == val 일 때 종료된다.

다음은 find 함수의 원형을 찾을 때 필요한 파츠 중 하나다. 위 while문의 조건 (*first == val) 부분을 나타낸다. 역시 보기 쉽게 편집했다.

// predefined_ops.h

template<typename Value>
struct _Iter_equals_val
{
	Value& mValue;
    
    explicit _Iter_equals_val(Value& _value)
    	: mValue(_value)
    {}
    
    template<typename Iterator>
    bool operator()(Iterator it)
    {
    	return *it == mValue;
    }
};

---

std::unique()

// unique 함수의 원형
template<typename ForwardIterator, typename BinaryPredicate>
ForwardIterator __unique(ForwardIterator first, ForwardIterator last,
	BinaryPredicate binary_pred)
{
	// Skip the beginning, if already unique.
	first = adjacent_find(first, last, binary_pred);
	if (first == last)
		return last;

	// Do the real copy work.
	ForwardIterator dest = first;
	++first;
	while (++first != last)
		if (!binary_pred(dest, first))
			*++dest = move(*first);
	return ++dest;
}

// 두 종류의 unique 함수
// 첫 번째 버전의 unique
template<typename ForwardIterator, typename BinaryPredicate>
inline ForwardIterator unique(ForwardIterator first, ForwardIterator last)
{
	return __unique(first, last, __iter_equal_to_iter());
}

// 두 번째 버전의 unique
template<typename ForwardIterator, typename BinaryPredicate>
inline ForwardIterator unique(ForwardIterator first, ForwardIterator last,
	BinaryPredicate binary_pred)
{
	return __unique(first, last, __iter_comp_iter(binary_pred);
}

 

__iter_equal_to_iter()와 __iter_comp_iter() 역시 predefined_ops.h에 정의되어 있다. 다음은 해당 부분의 코드다.

// predefined_ops.h

// __iter_equal_to_iter
struct _Iter_equal_to_iter
{
	template<typename Iterator1, typename Iterator2>
    bool operator()(Iterator1 it1, Iterator2 it2) const
    { 
    	return *it1 == *it2;
    }
};

inline _Iter_equal_to_iter __iter_equal_to_iter()
{ 
	return _Iter_equal_to_iter();
}

///////////////////////////////////////////////////////////////

// __iter_comp_iter
template<typename Compare>
struct _Iter_comp_iter
{
	Compare mComp;
    
    explicit constexpr _Iter_comp_iter(Compare comp)
		: mComp(move(comp))
    {}

	template<typename Iterator1, typename Iterator2>
    constexpr bool operator()(Iterator1 it1, Iterator2 it2)
    { 
    	return bool(mComp(*it1, *it2)); 
    }
};

template<typename Compare>
constexpr inline _Iter_comp_iter<Compare> __iter_comp_iter(Compare comp)
{ 
	return _Iter_comp_iter<Compare>(move(comp));
}