Отсортировать массив, чтобы сначала шли элементы массива которые есть в другом массиве

int arr1[] = {15, 7, 2, 2, 105};
int arr2[] = {3, 2, 12 , 7, 15, 1, 0, 100};

#include <iostream>
#include <iterator>
#include <algorithm>
#include <ranges>
namespace rng = std::ranges;
 
// нужна поддержка c++20
int main()
{
    int arr1[] = { 15, 7, 2, 2, 105 };
    int arr2[] = { 3, 2, 12 , 7, 15, 1, 0, 100 };
    rng::sort(arr1); // сортируем 1й массив для двоичного поиска 
    auto subr = rng::partition(arr2, [&arr1](auto val) {return rng::binary_search(arr1, val); }); // разбиваем 2й массив на две части
    rng::sort(subr); // сортируем 2ю часть 2го массива
    rng::sort(arr2, subr.begin()); // сортируем 1ю часть 2го массива
    rng::copy(arr2, std::ostream_iterator<int>{std::cout, " "}); // вывод на экран
}

#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
 
enum {N = 5, M = 8};
 
void printf_arr (int [], int);
bool element_in (int [], int, int);
 
int main (void) {
    int arr1[N] = {15, 7, 2, 2, 105};
    int arr2[M] = {3, 2, 12 , 7, 15, 1, 0, 100};
 
    printf_arr(arr1, N);
    printf_arr(arr2, M);
 
    int k = 0;
    for (int i = 0; i < M; i++)
        if ( element_in(arr1, N, arr2[i]) )
            swap(arr2[i], arr2[k++]);
 
    sort(arr2, arr2 + k);
    sort(arr2 + k, arr2 + M);
 
    cout << endl;
    printf_arr(arr2, M);
    return 0;
}
// -------------------------------------------------------------
void printf_arr (int a[], int size) {
    for (int i = 0; i < size; i++)
        cout << setw(4) << a[i];
    cout << endl;
}
// -------------------------------------------------------------
bool element_in (int a[], int size, int value) {
    bool result = false;
    for (int i = 0; i < size && !result; i++)
        result = (a[i] == value);
    return result;
}
// -------------------------------------------------------------

#include <vector>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
 
void printf_arr (vector <int>);
bool element_in (int, vector <int>);
 
int main (void) {
    vector <int> a = {15, 7, 2, 2, 105};
    vector <int> b = {3, 2, 12 , 7, 15, 1, 0, 100};
 
    printf_arr(a);
    printf_arr(b);
 
    size_t k = 0;
    for (size_t i = 0; i < b.size(); i++)
        if ( element_in(b[i], a) )
            swap(b[i], b[k++]);
 
    sort(&b[0], &b[k]);
    sort(&b[k], &b[b.size()]);
 
    cout << endl;
    printf_arr(b);
    return 0;
}
// -------------------------------------------------------------
void printf_arr (vector <int> a) {
    for (int n : a)
        cout << setw(4) << n;
    cout << endl;
}
// -------------------------------------------------------------
bool element_in (int value, vector <int> a) {
    bool result = false;
    for (size_t i = 0; i < a.size() && !result; i++)
        result = (value == a[i]);
    return result;
}
// -------------------------------------------------------------

#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
 
void printf_arr (int a[], size_t size) {
    for (size_t i = 0; i < size; i++)
        cout << setw(4) << a[i];
    cout << endl;
}
 
int main (void) {
    int a[] = {15, 7, 2, 2, 105};
    int b[] = {3, 2, 12 , 7, 15, 1, 0, 100};
 
    size_t a_size = end(a) - begin(a);
    size_t b_size = end(b) - begin(b);
 
    printf_arr(a, a_size);
    printf_arr(b, b_size);
 
    size_t k = 0;
    for (size_t i = 0; i < b_size; i++)
        if (find(begin(a), end(a), b[i]) != end(a))
            swap(b[i], b[k++]);
 
    sort(&b[0], &b[k]);
    sort(&b[k], &b[b_size]);
 
    cout << endl;
    printf_arr(b, b_size);
    return 0;
}

int b[] = { 3, 2, 12, 7, 15, 1, 0, 100 };
    
    size_t len = sizeof(b) / sizeof(b[0]);
        std::printf("%d", len);
        std::cin.get();

#include <iostream>
 
int main (void) {
    int a[] = {1, 2, 3};
    std::cout << std::end(a) - std::begin(a) << std::endl;
    return 0;
}

 #include <iostream>
#include <algorithm>
using namespace std;
 
int main() {
    const int arr1[] = { 1, 3, 4, 2, 5 };
    const int arr2[] = { 4, 1, 2 };
 
    int arr3[5];
    copy(arr2, arr2 + 3, arr3);
 
    sort(arr3, arr3 + 3);
    cout << "Sorted array: ";
    for (int i = 0; i < 3; i++) {
        cout << arr3[i] << " ";
    }
    cout << endl;
 
    return 0;
}

#include <iostream>
#include <algorithm>
#include <iterator>
int main()
{
    int arr1[] = { 15, 7, 2, 2, 105 };
    int arr2[] = { 3, 2, 12 , 7, 15, 1, 0, 100 };
    auto end_arr1_ptr=arr1+sizeof(arr1)/sizeof(*arr1);
    std::sort(arr1, end_arr1_ptr);
    size_t count_same_elements(0);
 
    std::partition(arr2, arr2+sizeof(arr2)/sizeof(*arr2),
                   [arr1, &count_same_elements](int a)
                   {
                    auto ptr=std::lower_bound(std::begin(arr1), std::end(arr1), a);
                    if(ptr!=std::end(arr1) && *ptr==a)
                    {
                        ++count_same_elements;
                        return true;
                    }
                    return false ;
                   }
                   );                  
                   std::sort(arr2, arr2+count_same_elements);
                   std::sort(arr2+count_same_elements, arr2+sizeof(arr2)/sizeof(*arr2));
                   for(auto a:arr2)std::cout<<a<<' ';
 
 
    return 0;
}

// some module
#include <cstdint> // helper types
// some classes and functions
 
// and some function for example
void dosometing()
{
    uint64_t a,b;
    std::swap(a, b); // ‘swap’ is not a member of ‘std’
}