Yet another tool missing from C, but found in other programming languages, is the capability to stick together two arrays. The result is a single, larger array containing the elements from the two originals. With C, of course, you can always code your own function to handle the task.

The strcat() function does array concatenation, gluing together two character arrays — but only character arrays (strings). Beyond strings, an array concatenation function must know the array’s data type. This tidbit requires either separate, data type specific functions or that the data type be passed as an argument to a generic array concatenation function.

Another required knowledge tidbit is the array’s element count. A string is terminated with the null character, but any other type of array has no guaranteed final element value. As the arrays are referenced by address (pointer) within the function, you can’t use the sizeof keyword to determine the number of elements: In a function, sizeof returns the pointer’s size, not the array size.

Here is my intarraycat() function, which concatenates two integer arrays:

/* concatenate two integer arrays */
int *intarraycat(int *a, int asize, int *b, int bsize)
{
    int *c,x;

    /* allocate storage for new array */
    c = malloc( sizeof(int) * (asize+bsize) );

    /* concatenate upon success */
    if( c!=NULL )
    {
        /* copy first array */
        for( x=0; x<asize; x++ )
            *(c+x) = *(a+x);
        /* copy second array */
        for( x=0; x<bsize; x++ )
            *(c+x+asize) = *(b+x);
    }

    return(c);
}

The four arguments are two pairs, the arrays and their number of elements. Variable c is allocated to store both array’s elements, using the two size values to set the storage size. Upon success, the if statement block executes. Otherwise, NULL is returned, which is tested for in the main() function.

Two for loops in the function assign array elements. Pointer notation is used as the array data is passed as a pointer and referenced in variable c.

In the second for loop, the offset for buffer c is calculated by using both looping variable x and the size of the first array, asize. This expression ensures that the elements in new array c are contiguous.

The function returns pointer c, which references the buffer containing the combined arrays.

The main() function declares two integer arrays and assigns them values, outputs each array, then calls the intarraycat() function in these statements:

    /* concatenate and output */
    cat = intarraycat(a,as,b,bs);
    if( cat!=NULL )
    {
        printf("Result: ");
        for( x=0; x<as+bs; x++ )
            printf(" %d",*(cat+x));
        putchar('\n');
    }
    else
    {
        puts("Concatenation error");
    }

Integer pointer cat captures the return value from the intarraycat() function. If the value is not NULL, a for loop outputs the new concatenated array. Otherwise, an error message is output. Variables a and b represent the two original integer arrays; as and bs are the array sizes. Click here to view the full code. Here is sample output:

Array 'a': 11 22 33 44 55
Array 'b': 89 78 67 56 45 1
Result: 11 22 33 44 55 89 78 67 56 45 1

I suppose a more graceful way to concatenate two arrays might exist. Then again, in other programming languages, the coders need not worry about elegant coding because such a function already exists. In C, we must try harder.