Merge two integer arrays in C - c

Question

I am trying to program a function to merge two signed integer arrays. The idea is to get the contents of src, reallocate memory in dest to insert the contents of src after its own contents. If dest is NULL, the function must allocate memory space to store src + 1. If there is an error the function must return NULL. The function must also free the memory space allocated to src after the merge. Integer arrays are terminated by an int called "End Of Buffer" (-1 in my example below).
the problem seems to be related to the realloc function, can you help me to fix it?
Here is the full code that produces the error :
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
ssize_t my_put_int(int nbr, int fd)
{
char c = 0;
char negative = '-';
ssize_t len = 0;
if (nbr < 0) {
len += write(fd, &negative, 1);
len += my_put_int(-nbr, fd);
} else if (nbr < 10) {
c = nbr + 48;
len += write(fd, &c, 1);
} else {
len += my_put_int(nbr / 10, fd);
c = nbr % 10 + 48;
len += write(fd, &c, 1);
}
return len;
}
ssize_t my_put_int_arr(int *arr, int eob, int fd)
{
size_t count = 0;
int *ptr = NULL;
if (!arr || fd < 0)
return -1;
ptr = arr;
while (*ptr != eob) {
count += my_put_int(*ptr, fd);
ptr++;
}
return count;
}
size_t my_int_arr_len(int *arr, int eob)
{
size_t count = 0;
if (!arr)
return -1;
while (*arr != eob) {
count++;
arr++;
}
return count;
}
int *my_int_array_concat(int *dest, int *src, int eob)
{
size_t src_size = 0, dest_size = 0;
if (!src) return NULL;
src_size = my_int_arr_len(src, eob);
if (dest == NULL) {
dest = malloc(sizeof(int) * (src_size + 1));
if (dest == NULL) return NULL;
for (size_t i = 0; i < src_size; i++) dest[i] = src[i];
dest[src_size] = eob;
free(src);
return dest;
}
dest_size = my_int_arr_len(dest, eob);
printf("Dest size %ld, src size %ld\n", dest_size, src_size); // Debug
dest = realloc(dest, sizeof(int) * (dest_size + src_size + 1));
printf("New dest size %ld\n", my_int_arr_len(dest, -1)); // Debug
if (!dest) return NULL;
for (size_t i = 0; i < src_size; i++) dest[i] = src[i];
dest[src_size] = eob;
free(src);
return dest;
}
int main() //test main
{
int *src = malloc(sizeof(int) * 2);
src[0] = 3;
src[1] = -1;
int *dest = malloc(sizeof(int) * 3);
dest[0] = 2;
dest[1] = 1;
dest[2] = -1;
dest = my_int_array_concat(dest, src, -1);
my_put_int_arr(dest, -1, 1);
return 0;
}
I get this result :
Dest size 2, src size 1
New dest size 2
3

Answer 1

Use following concat function -
int *my_int_array_concat(int *dest, int *src, int eob)
{
size_t src_size = 0, dest_size = 0;
if (!src) return NULL;
src_size = my_int_arr_len(src, eob);
if (dest == NULL) {
dest = malloc(sizeof(int) * (src_size + 1));
if (dest == NULL) return NULL;
for (size_t i = 0; i < src_size; i++) dest[i] = src[i];
dest[src_size] = eob;
return dest;
}
dest_size = my_int_arr_len(dest, eob);
dest = realloc(dest, sizeof(int) * (dest_size + src_size + 1));
if (!dest) return NULL;
for (size_t i = 0; i < src_size; i++) dest[dest_size+i] = src[i];
dest[dest_size+src_size] = eob;
free(src);
return dest;
}
It should work.

Answer 2

Here is another (not tested) variant of the function :
int* my_int_array_concat( int* dst, int* src, int eob )
{
int* result;
int dst_size;
int src_size;
int elements_count;
src_size = my_int_arr_len( src, eob );
if( src_size == -1 )
src_size = 0;
dst_size = my_int_arr_len( dst, eob );
if( dst_size == -1 )
dst_size = 0;
elements_count = src_size + dst_size;
result = realloc( dst, sizeof(int) * (elements_count + 1) );
if( result == NULL )
return NULL;
if( src_size )
memcpy( result + dst_size, src, sizeof(int) * src_size );
result[elements_count] = eob;
if( src )
free( src );
return result;
}