cppArrayAElNotInBSTLLike

#include <iostream>

template <typename T> bool sortUp(const T& a, const T& b)
{
    return a < b;
}

template <typename T> bool sortDown(const T& a, const T& b)
{
    return a > b;
}

template <typename T> void sort(T* begin, T* const end, bool(*sortCrit)(const T&, const T&), void(*print)(const T*, const T*) = nullptr)
{
    if (print) print(begin, end);
    T tmp;
    for (T* head{ begin }; head != end; ++head)
    {
        for (T* tail{ end - 1 }; tail != head; --tail)
        {
            if (sortCrit(*tail, *head))
            {
                tmp = *tail;
                *tail = *head;
                *head = tmp;
                if (print) print(begin, end);
            }
        }

    }
    if (print) print(begin, end);
}

template <typename T>
void print(const T* begin, const T* const end)
{
    while (begin != end)
    {
        std::cout << *begin++ << ' ';
    }
    std::cout << '\n';
}

template <typename T>
T* unique(T* begin, T* const end)
{
    T* insertPos{ begin + 1 };
    for (; (insertPos != end) and (*insertPos != *(insertPos - 1)); ++insertPos);
    if (insertPos == end) return end;

    begin = insertPos + 1;
    while (begin != end)
    {
        if (*(insertPos - 1) != *begin)
        {
            *insertPos++ = *begin;
        }
        ++begin;
    }
    return insertPos;
}

template <typename T>
T* uniqualize(T* const begin, T* const end)
{
    sort(begin, end, sortUp<int>);
    return unique(begin, end);
}

template <typename T>
const T* binSearch(const T* const begin, const T* const end, const T& key)
{
    const T* left{ begin };
    const T* right{ end - 1 };
    const T* mid;
    while (true)
    {
        mid = left + ((right - left) / 2);
        if (key == *mid) { return mid; };
        if (key < *mid) { right = mid - 1; }
        if (key > *mid) { left = mid + 1; }
        if (left > right) { return end; };
    }
}

template <typename T>
T* remove_if_ref(T* begin, T* const end, const T* const beginRef, const T* const endRef, bool(*pred)(const T*, const T*, const T&))
{
    T* insertPos{ begin };
    for (; (insertPos != end) and !pred(beginRef, endRef, *insertPos); ++insertPos);
    if (insertPos == end) return end;

    begin = insertPos + 1;
    while (begin != end)
    {
        if (!pred(beginRef, endRef, *begin))
        {
            *insertPos++ = *begin;
        }
        ++begin;
    }
    return insertPos;
}

template <typename T>
bool isIn(const T* const begin, const T* const end, const T& el)
{
    return (binSearch(begin, end, el) != end);
}

template <typename T>
bool notIn(const T* const begin, const T* const end, const T& el)
{
    return (binSearch(begin, end, el) == end);
}

template <typename T>
size_t distance(const T* const begin, const T* const end)
{
    return end - begin;
}

template <typename T>
size_t copy(const T* srcB, const T* const srcE, T* destB, T* const destE)
{
    size_t copyCount{ 0 };
    while (destB != destE and srcB != srcE)
    {
        *destB++ = *srcB++;
        ++copyCount;
    }
    return copyCount;
}

int* createArr(size_t size)
{
    return new int[size];
}

void deleteArr(int* ptr)
{
    delete[] ptr;
}

int main()
{
    const int arrASize{ 15 };
    const int arrBSize{ 15 };
    int arrA[arrASize] { 6,1,4,2,8,9,4,26,2,7,8,11,7,2,3 };
    int arrB[arrBSize] { 1,8,29,2,2,9,11,1,2,5,8,34,12,9,8 };

    std::cout << "Original arrays:\n";
    print(arrA, arrA + arrASize);
    print(arrB, arrB + arrBSize);

    int* uniqueAPos{ uniqualize(arrA, arrA + arrASize) };
    int* uniqueBPos{ uniqualize(arrB, arrB + arrBSize) };

    //std::cout << "\nOriginal arrays without duplicates:\n";
    //print(arrA, uniqueAPos);
    //print(arrB, uniqueBPos);

    int* resAPos{ remove_if_ref(arrA, uniqueAPos, arrB, uniqueBPos, isIn<int>) };
    //std::cout << "\nArrayA elements not in arrayB:\n";
    //print(arrA, resAPos);

    auto arrCSize{ distance(arrA, resAPos) };
    auto arrC{ createArr(arrCSize) };
    copy(arrA, resAPos, arrC, arrC + arrCSize);
    std::cout << "\nArrayA elements not in arrayB without duplicates:\n";
    print(arrC, arrC + arrCSize);
    deleteArr(arrC);

    return 0;
}