cppArrayDiffElementOfTwoArraySTLLike

#include <iostream>

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

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

template <typename T> void sort(T* begin, T* end, bool(*sortCrit)(T, T), void(*print)(T*, 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(T* begin, T* end)
{
    while (begin != end)
    {
        std::cout << *begin++ << ' ';
    }
    std::cout << '\n';
}

template <typename T>
T* unique(T* begin, T* 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* begin, T* end)
{
    sort(begin, end, sortUp<int>);
    return unique(begin, end);
}

template <typename T>
T* merge(T* beginA, T* endA, T* beginB, T* endB, T* beginDest)
{
    while (beginA != endA and beginB != endB)
    {
        *beginDest++ = *beginA < *beginB ? *beginA++ : *beginB++;
    }
    while (beginA != endA)
    {
        *beginDest++ = *beginA++;
    }
    while (beginB != endB)
    {
        *beginDest++ = *beginB++;
    }
    return beginDest;
}

template <typename T>
T* dedup(T* begin, T* end)
{
    T* next{ begin };
    ++next;
    T* out{ begin };

    while (begin != end)
    {
        if (*begin != *next)
        {
            *out++ = *begin++;
            ++next;
        }
        else
        {
            begin += 2;
            next += 2;
        }
    }
    return out;
}
template <typename T>
size_t distance(T* begin, T* end)
{
    return end - begin;
}

template <typename T>
size_t copy(T* srcB, T* srcE, T* destB, T* 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,11,26,2,7,8,11,2,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) };

    int* mergeAB{ createArr(distance(arrA,uniqueAPos) + distance(arrB,uniqueBPos)) };
    int* mergePos{ merge(arrA, uniqueAPos,arrB, uniqueBPos, mergeAB) };
    //std::cout << "\nMerged elements of two arrays:\n";
    //print(mergeAB, mergePos);
    int* dedupPos{ dedup(mergeAB, mergePos) };
    //std::cout << "\nDifferent elements of two arrays without duplicates:\n";
    //print(mergeAB, dedupPos);

    auto arrCSize{ distance(mergeAB, dedupPos) };
    auto arrC{ createArr(arrCSize) };
    copy(mergeAB, dedupPos, arrC, arrC + arrCSize);
    std::cout << "\nDifferent elements of two arrays without duplicates:\n";
    print(arrC, arrC + arrCSize);

    deleteArr(mergeAB);
    deleteArr(arrC);
}