sprintf do what you need.

Little example

char str[128];
int i=0;
int index = 0;
for (i=0; i<5; i++)
   index += sprintf(&str[index], "%d", a[i]);

snprintf takes care of the str length

char str[128];
int i=0;
int index = 0;
for (i=0; i<5; i++)
   index += snprintf(&str[index], 128-index, "%d", a[i]);

the following proposed code:

1. cleanly compiles
2. performs the desired functionality
3. demonstrates the use of strcpy() and sprintf()
4. avoids the use of 'magic' numbers
5. lets the compiler calculate the number of entries in the array[]

and now, the proposed code:

#include <stdio.h>
#include <string.h>


int main( void )
{
    int array[] = {1, 6, 2, 4, 4};
    char string[255] = {0};

    /*do something*/
    strcpy( string, "[" );
    for( size_t i = 0; i < (sizeof(array)/sizeof(int)) -1; i++ )
    {
        sprintf( &string[ strlen(string) ],  "%d, ", array[i] );
    }

    sprintf( &string[ strlen(string) ],  "%d", array[4] );
    strcat( string, "]" );

    printf("%s\n", string);
}

a run of the proposed code results in:

[1, 6, 2, 4, 4]

There is no direct function to do that.

You'll have to use sprintf.

Depending on what you really want, there are several possible answers to this question:

int example[5] = {1,2,3,4,5};
char output[5];
int i;

Straight copy giving ASCII control characters 1 - 5

for (i = 0 ; i < 5 ; ++i)
{
    output[i] = example[i];
}

characters '1' - '5'

for (i = 0 ; i < 5 ; ++i)
{
    output[i] = example[i] + '0';
}

strings representing 1 - 5.

char stringBuffer[20]; // Needs to be more than big enough to hold all the digits of an int
char* outputStrings[5];

for (i = 0 ; i < 5 ; ++i)
{
    snprintf(stringBuffer, 20, "%d", example[i]);
    // check for overrun omitted
    outputStrings[i] = strdup(stringBuffer);
}

Assuming the "int array" is values in the 0-9 range (which is the only way that makes sense to convert an "int array" length 10 to a 10-character string) - a bit of an exotic way:

string s = new string(Array.ConvertAll(RXBuffer, x => (char)('0' + x)));

But pretty efficient (the char[] is right-sized automatically, and the string conversion is done just with math, instead of ToString()).

Edit: with the revision that makes it clear that these are actually ASCII codes, it becomes simpler:

string s = new string(Array.ConvertAll(RXBuffer, x => (char)x));

Although frankly, if the values are ASCII (or even unicode) it would be better to store it as a char[]; this covers the same range, takes half the space, and is just:

string s = new string(RXBuffer);

you could write a little function

string int_array_to_string(int int_array[], int size_of_array) {
  string returnstring = "";
  for (int temp = 0; temp < size_of_array; temp++)
    returnstring += itoa(int_array[temp]);
  return returnstring;
}

^untested!

a slightly different approach

string int_array_to_string(int int_array[], int size_of_array) {
  ostringstream oss("");
  for (int temp = 0; temp < size_of_array; temp++)
    oss << int_array[temp];
  return oss.str();
}

• result is not zero-terminated. You should allocate one byte more.

• To my taste, there are too many allocations. Compute the required size, and allocating once. You already allocate 32 bytes per array element, so

    char * result = malloc(length * 32 + whatever_extra_space_necessary);
  

• Now recall that sprintf returns an amount of bytes it actually printed, and remove a superfluous call to strlen:

    char * where = result;
    for (size_t i = 0; i < length; i++) {
        size_t printed = sprintf(where, "%d, ", arr[i]);
        where += printed;
    }
  

• Your code prints an unpleasant ", " after the last element of an array. If it is a conscious decision, it is all right; if it is not, consider printing the first element separately:

    print("%d", arr[0]);
    for (i = 1; ....)
        print(", %d", arr[i]);
  

Since charArray is not a string, you can't use the standard functions like strcpy(), or strlen(). Instead, copy every character, and add '\0' at the end. sizeof(charArray) / sizeof(int) can tell you how many characters to copy.

size_t sz = sizeof(charArray) / sizeof(int);
char *string = malloc(sz + 1);
for (int i = 0; i < sz; i++)
{
    string[i] = charArray[i];
}
string[sz] = '\0';