Собрать элементы массива A, которые не включаются в массив B

#include<iostream>
 
typedef int buf_t[1024];
 
typedef buf_t* bufarr_t[1024];
 
void allocate(bufarr_t* bufarr, int m, int n, int q, int i)
 
{
 
buf_t buffer = { 0 };
 
(*bufarr)[i] = &buffer;
 
if (m <= 0 && n <= 0 && q <= 0)
 
{
 
(*bufarr)[i] = NULL;
 
return;
 
}
 
else if (m <= 0 && n <= 0) {
 
return allocate(bufarr, 0, 0, q - 1024, i + 1);
 
}
 
else if (m <= 0) {
 
return allocate(bufarr, 0, n-1024, q, i + 1);
 
}
 
else {
 
return allocate(bufarr, m-1024, n, q, i + 1);
 
}
 
}
 
int main()
 
{
 
bufarr_t bufarr = { nullptr };
 
int m = 0, n = 0, q = 0;
 
std::cin >> m;
 
std::cin >> n;
 
q = m + n;
 
allocate(&bufarr, m, n, q, 0);
 
system("pause");
 
return 0;
 
}

#include <iostream>
#include <algorithm>
#include <set>
using namespace std;
 
int main(int argc, char* argv[])
{
    int A[]={1,2,3,4,5,6},
    szA=sizeof(A)/sizeof(*A),
    B[]={25,2,33,44,5,6},
    szB=sizeof(B)/sizeof(*B);
 
set<int> A_set(A, A+szA), B_set(B, B+szB), C_set;  
set_difference(A_set.begin(), A_set.end(),
                    B_set.begin(), B_set.end(), inserter(C_set, C_set.begin()));
ostream_iterator<int> osit(cout, " ");
copy(C_set.begin(), C_set.end(), osit);
 
cout<<endl;
cin.get();
return 0;
}

void*notMalloc(std::size_t size)
{
    const std::size_t storageSize=1<<20;
    static unsigned char storage[storageSize];
    static unsigned char*freeStorage=storage;
    static unsigned char*const endStorage=storage+storageSize;
 
    return freeStorage+size<=endStorage?
                (freeStorage+=size)-size:
                nullptr;
}

class FirstParent
{
public:
    virtual~FirstParent(){}
    int x;
};
 
class SecondParent
{
public:
    virtual~SecondParent(){}
    int y;
};
 
class Child:public SecondParent,public FirstParent
{
public:
};
 
int main()
{
    //аллокатор базового типа FirstParent, который не умеет создавать потомков FirstParent
    std::allocator<FirstParent> baseAllocator;
    //аллокатор умеющий делать потомка Child
    std::allocator<Child> childAllocator(baseAllocator);
    //делаем ребеночка и сохраняем в указатель на БАЗОВЫЙ класс. Потому что полиморфизм
    FirstParent*child=childAllocator.allocate(1);
    //В childAllocator этот указатель не сунешь, значит суем в baseAllocator
    //Опс, программа крашится
    baseAllocator.deallocate(child,1);
    return 0;
}