Занести в новый массив элементы, не являющиеся общими для двух заданных массивов

#include<iostream>
#include<time.h>
using namespace std;
 
void add_to_end_of_array(int *& ar, int & size, int value)
{
    int * temp = new int[size + 1];
 
    for (int i = 0; i < size; i++)
        temp[i] = ar[i];
 
    temp[size] = value;
 
    delete[]ar;
    ar = temp;
    size++;
 
    
}
void print_array(int*mas, int size)
{
    for (int i = 0; i < size; i++)
        cout << mas[i] << " ";
    cout << endl << endl;
}
void randomize_array(int* mas, int size)
{
    for (int i = 0; i < size; i++)
        mas[i] = rand() % 100;
}
bool contains(int * a, int size, int value)
{
    for (int i=0;i<size;i++)
    if (a[i] == value)
        return true;
    return false;
}
void obel(int*&obw, int*mas, int*mas2, int size1, int size2, int &size3)
{
    obw = nullptr, size3 = 0;
    for (int i = 0; i<size1; i++)
    {
        if (!contains(obw, size3, mas[i]))
            add_to_end_of_array(obw, size3, mas[i]);
    }
 
    for (int i = 0; i<size2; i++)
    {
        if (!contains(obw, size3, mas2[i]))
            add_to_end_of_array(obw, size3, mas2[i]);
    }
}
 
void main()
{
    srand(time(0));
    int size = 10, size2 = 10;
    /*cout << "Enter size1: ";
    cin >> size;
    cout << "Enter size2: ";
    cin >> size2;*/
    int*mas2 = new int[size2]{1,2,3,4,5,6,2,7,3,0};
    int*mas = new int[size]{4,5,6,7,8,9,11,12,4,8};
    
    int*obw, size3;
    //randomize_array(mas, size);
    //randomize_array(mas2, size2);
    cout << "massiv 1: ";
    print_array(mas, size);
    cout << "massiv 2: ";
    print_array(mas2, size2);
    obel(obw, mas, mas2, size, size2,size3);
    cout << "massiv 3: ";
    print_array(obw, size3);
    delete[]mas;
    delete[]mas2;
    delete[]obw;
 
}

http://rextester.com/KDM12177
 
#include <iostream>
#include <cassert>
#include <ctime>
 
// --- заполняет массив случайными числами
void fill(int* arr, const size_t len)
{
    assert(arr);
    assert(len>0);
    for(size_t n=0; n<len; ++n)
        arr[n] = rand() % 100;
}
 
// --- показывает в консольке содержимое массива
void view(const char* name, const int* arr, const size_t len)
{
    assert(name);
    
    if(len==0)
        return std::cout << name << "[0] = { empty };"
            << std::endl,
        void();
    
    assert(arr);
    assert(len!=0);
        
    std::cout << name << "["<<len<<"] = { ";
 
    for(size_t n=0; n < len-1; ++n)
        std::cout << arr[n] <<", ";
        
    std::cout << arr[len-1] << " };"
        << std::endl;
}
 
// --- поиск в массиве элемента
bool findvalue(const int* arr, const int v, const size_t len)
{
    assert(arr);
    assert(len!=0);
    for(size_t n=0; n<len;++n)
        if(arr[n]==v)
            return true;
    return false;
}
 
// создает массив из элементов,
// которые не являются общими для исходных массивов
// возвращает количество элементов созданного массива
// оба исходных массива должны быть не нулевыми
size_t unique_value(const int* arr1, const size_t len1, const int* arr2, const size_t len2, int** dst)
{
    assert(arr1);
    assert(arr2);
    assert(len1!=0);
    assert(len2!=0);
 
    // вычисляем больший массив
    const int* arrb = len1>len2? arr1 : arr2;
    size_t lenb = len1>len2? len1 : len2;
    
    // вычисляем меньший массив
    const int* arrs = len1>len2? arr2 : arr1;
    size_t lens = len1>len2? len2 : len1;
    
    // максимально возможный размер 3го массива:
    // сумма размеров исходных массивов.
    int* re = new int[len1 + len2];
    
    // --- сначала находим элементы не являющиеся общими lens
    // из диапазона от нуля до lens
    size_t i=0;
    for(size_t n=0; n<lens; ++n)
    {
        if( !findvalue(arrb, arrs[n], lenb) )
            re[i]=arrs[n], ++i;
        
        if( !findvalue(arrs, arrb[n], lens) )
            re[i]=arrb[n], ++i;
    }
    
    // --- теперь проверяем оставшийся хвостик большего массива
    // в диапазоне от lens до lenи
    for(size_t n=lens; n<lenb; ++n)
    {
        if( !findvalue(arrs, arrb[n], lens) )
            re[i]=arrb[n], ++i;
    }
 
    // --- теперь мы знаем точное количество результирующих данных
    // и копируем данные в итоговый массив
    if(i==0)
        return 0;
    
    *dst = new int[i];
    for(size_t n=0; n<i; ++n)
        (*dst)[n] = re[n];
    
    delete [] re;
    return i;
}
 
 
int main()
{
    std::cout << "Hello, world!\n";
    srand(time(0));
    
    size_t N=0, M=0;
    
    std::cout <<"input N: " ; std::cin >> N;
    std::cout <<"input M: " ; std::cin >> M;
    
    assert(N!=0);
    assert(M!=0);
    
    int* first  = new int[N];
    int* second = new int[M];
    
    fill(first , N);
    fill(second, M);
 
    // --- генерация массива, который содержит элементы
    // которые не являются общими для исходных массивов
    int* result = nullptr;
    const size_t lenResult = unique_value(first, N, second, M, &result);
    
    // --- покажем результаты:
    std::cout << std::endl;
    view("first" , first , N);
    view("second", second, M);
    view("result", result, lenResult);
    
    // --- пребиремся за собой
    delete [] first;
    delete [] second;
    delete [] result;
}