Exercise with array and pointer - arrays

Question

I am a beginner in C. I want to write a function to return an array containing all elements common to two given arrays containing distinct positive integers.
Sample input/output is in the following table:
|input parameters | return |
| ---------- | -------- |
|{1, 8, 3, 2}, {4, 2, 6, 1} | {1, 2} |
|{1, 8, 3, 2, 6}, {2, 6, 1} | {2, 6, 1} |
|{1, 3, 7, 9}, {7, 1, 9, 3} | {1, 3, 7, 9}|
|{1, 2}, {3, 4} | {} |
|{}, {1, 2, 3} | {} |
|{1, 2}, {} | {} |
|{1, 2}, null | null |
|null, {} | null |
|null, null | null |
int f(int first[], int second[], int first_len, int second_len, int result_len)
{
if (first == NULL || second == NULL)
{
return NULL;
}
if (first_len == 0 || second_len == 0) return malloc(0);
int min = (first_len < second_len) ? first_len : second_len;
int *a, *b;
if (min == first_len)
{
a = first;
b = second;
}
else
{
a = second;
b = first;
}
int *c = malloc(min);
int k = 0;
for (int i = 0; i <sizeof(*a); i++)
{
for (int j = 0; j < sizeof(*b) ; j++)
{
if (a[i] == b[j])
{
c[k] = a[i];
k++;
}
}
}
int *retArray = malloc(k * result_len);
result_len = sizeof(retArray)/sizeof(*retArray);
for (int t = 0; t < result_len; t++)
{
retArray[t] = c[t];
}
return retArray;
}
int main()
{
int first[] = {1,3,8,9};
int second[] = {3,5,8};
int result_len;
int first_len = sizeof(first)/sizeof(*first);
int second_len = sizeof(second)/sizeof(*second);
printf("%d\n", f(first,second,first_len,first_len,result_len));
return 0;
}
This code doesn't give the result that I need can anyone help me out?

Answer 1

Without discussing the actual algorithmic exercise, the confusion here seems to be in the return type. You can't return more than one value in C code. The value can however be struct or a pointer to allocated memory. Code is worth a thousand words so consider the following example:
#include <stdio.h>
#include <stdlib.h>
void foo(char *arr)
{
// fill the given memory location with requested data
arr[0] = '4';
arr[1] = '2';
arr[2] = '0';
// note absent or empty return;
}
int main()
{
// allocate some space for return value
char *arr = malloc(3 * sizeof(char));
// tell the function where to store the result by passing the arr pointer
foo(arr);
// the function has filled the array with some data
printf("%c%c%c\n", arr[0], arr[1], arr[2]);
// don't forget to free the allocated memory when it's no longer in use
free(arr);
return 0;
}
This technique is generally called 'returning by reference', as you are using a reference (pointer) to return the data as opposed to 'returning by value' when you directly return the number (or other data type).
You can of course also allocate the new block of memory in the function and then return the pointer like so:
char *foo()
{
char *arr = malloc(3 * sizeof(char));
// fill with requested data
return arr;
}
Although this makes it easier to forget to free the memory IMO.