Не могу разобраться с указателями

//output.c
#include <stdio.h>
 
void my_error(int *point_array, const int num)
{
    if (!point_array){
        printf("\nerror of memory\n");
        exit(num);
    }
}
 
void print (const int num, const int choise)
{
    switch(choise)
    {
        case 1: printf("%d ", num);
            break;
        case 2: printf("\n\n");
            break;
        case 3: printf("\nsourse array %x\n", num);
            break;
        case 4: printf("\narray a + array b: \n");
            break;
        case 5: printf("\nintersection array a and b\n");
            break;
        case 6: printf("\nintersection is 0\n");
            break;
        case 7: printf("\nelements of array a and not array b: \n");
            break;
        case 8: printf("\nelements of array b and not array a: \n");
            break;
    }
}

//main.c
 
#include <stdlib.h>
#include <time.h>
 
int *create_array(int size)
{
    int *tmp = 0, i = 0;
    tmp = (int*)malloc(size * sizeof(int));
    my_error(tmp, 4);
    for (i; i < size; ++i)
        tmp[i] = rand() % 100;
    return tmp;
}
 
void output_array(int * tmp, const int size, const int choise)
{
    int i = 0;
    for (i; i < size; ++i)
        print(tmp[i], choise);
}
 
void double_array(int *a, int *b, int *c, int n, int m)
{
    int i = 0, j;
    for (i; i < n; ++i)
        *(c + i) = *(a + i);
    j = i;
    for (i = 0; i < m; ++i)
        *(c + j++) = *(b + i);
}
 
int find(const int *c, const int num, const int size)
{
    int i = 0;
    for (i; i < size; ++i)
        if (c[i] == num)
            return 1;
    return 0;
}
 
void resize_array(int *c, const int size)
{
    int tmp = 0;
    tmp = realloc(c, size * sizeof(int));
    if (!tmp) exit(-1);
}
 
int intersection(const int *a, const int *b, int *c, const int n, const int m)
{
    int i = 0, j, tmp = 0, size = 0;
 
    for (i; i < n; ++i)
        for (j = 0; j < m; ++j)
        {
            if (!size)
            {
                if (a[i] == b[j])
                {
                    ++size;
                    c = create_array(size);
                    c[0] = a[i];
                }
            }
            else
            {
                if (a[i] == b[j])
                {
                    tmp = find(c, a[i], size);
 
                    if (!tmp)
                    {
                        ++size;
                        resize_array(c, size);
                        c[size - 1] = a[i];
                    }
                }
 
            }
        }
    return size;
}
 
void array_copy(int *in, int *out, const int size)
{
    int i = 0;
 
    for (i; i < size; ++i)
        in[i] = out[i];
}
 
void inclusive_not(const int *a, int *c, const int *tmp, const int n, const int tmp_size)
{
    int i = 0, j, k = 0, check, temp = 0;
 
    for (i; i < n; ++i)
    {
        check = 1;
 
        for (j = 0; j < tmp_size; ++j)
            if (a[i] == tmp[j])
            {
                check = 0; ++temp;
                break;
            }
        if (check)
            c[k++] = a[i];
    }
 
    if (temp > tmp_size)
        resize_array(c, temp - tmp_size);
}
 
int main()
{
    int *a_array = 0, *b_array = 0, *c_array = 0, *tmp_array;
    int n = 10, m = 20, tmp_size, tmp;
 
    srand(time(0));
    a_array = create_array(n);
    my_error(a_array, 1);
    b_array = create_array(m);
    my_error(b_array, 2);
    c_array = create_array(n + m);
    my_error(c_array, 3);
    double_array(a_array, b_array, c_array, n, m);
 
    print(10, 3);
    output_array(a_array, n, 1);
    print(n, 2); print(11, 3);
    output_array(b_array, m, 1);
    print(n, 2); print(n, 4);
    output_array(c_array, n + m, 1);
    free(c_array);
 
    tmp_size = intersection(a_array, b_array, c_array, n, m);
 
    if (!tmp_size)
    {
        print(n, 6);
        c_array = create_array(n + m);
        my_error(c_array, 5);
        double_array(a_array, b_array, c_array, n, m);
        print(n, 2); print(n, 4);
        output_array(c_array, n + m, 1);
        print(n, 2);
    }
    else
    {
        print(n, 2); print(n, 5);
        output_array(c_array, tmp_size, 1);
        tmp_array = create_array(tmp_size);
        array_copy(tmp_array, c_array, tmp_size);
        free(c_array);
 
        c_array = 0;
        c_array = create_array(n - tmp_size);
        my_error(c_array, 6);
 
        inclusive_not(a_array, c_array, tmp_array, n, tmp_size);
        print(n, 2); print(n, 7);
        output_array(c_array, n - tmp_size, 1);
        free(c_array);
 
        c_array = 0;
        c_array = create_array(m - tmp_size);
        my_error(c_array, 7);
 
        inclusive_not(b_array, c_array, tmp_array, m, tmp_size);
        print(n, 2); print(n, 8);
        output_array(c_array, m - tmp_size, 1);
        print(n, 2);
        free(tmp_array);
    }
 
    free(a_array);
    free(c_array);
    free(b_array);
    return 0;
}