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.

Copy the array item by item in a loop and store each value in a char. Then null terminate that char array so that it becomes a string. Or alternatively don't declare s3 as int to begin with.

• 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]);
  

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();
}

Assuming that your stringAscii array is:

int stringAscii[] = {72, 101, 108, 108, 111, 32, 
                     87, 111, 114, 108, 100};

And not:

int stringAscii = {"072", "101", "108", "108", "111", "032", 
                   "087", "111", "114", "108", "100"};

Which is incorrect for two reasons:

• you need to have stringAscii[] as your array name.
• You can't have string " " values as members of an integer array. That is type conflict in C.

You can dynamically allocate space for char *string using malloc, and add your ascii integer values to the dynamic array one at a time.

You can free the requested space at the end.

Something like this will help you get started:

#include <stdio.h>
#include <stdlib.h>

char *stringAsciiToString(int stringAscii[], const size_t size);

int
main(int argc, char *argv[]) {
    int stringAscii[] = {72, 101, 108, 108, 111, 32, 
                     87, 111, 114, 108, 100};

    const size_t size = sizeof(stringAscii)/sizeof(*stringAscii);

    char *string = stringAsciiToString(stringAscii, size);

    printf("Output -> '%s'\n", string);

    free(string);

    return 0;
}

char 
*stringAsciiToString(int stringAscii[], const size_t size) {
    int i, slen = 0;

    char *string = malloc((size+1) * sizeof(*string));
    if (!string) {
        printf("Cannot allocate memory\n");
        exit(EXIT_FAILURE);
    }

    for (i = 0; i < size; i++) {
        string[slen++] = stringAscii[i];
    }
    string[slen] = '\0';

    return string;
}

Output here: Demo

You can use sprintf to do it, or maybe snprintf if you have it:

char str[ENOUGH];
sprintf(str, "%d", 42);

Where the number of characters (plus terminating char) in the str can be calculated using:

(int)((ceil(log10(num))+1)*sizeof(char))

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);
}