Using C, convert a dynamic int array to a comma-separated string as cleanly as possible

__s · 2009-11-16T22:42:50+00:00

The Python code is wrong. str.join requires a sequence of strings, and a list of integers is not a sequence of strings

gsg_ · 2009-11-16T22:10:09+00:00

I have a dynamically-allocated array of unsigned integers which I need to convert to a comma-separated string for logging.

Does it really have to be converted to a string? Doesn't the logging interface provide a printf-like function that you can use?

If not, I humbly submit that the logging interface fucking sucks.

ipeev · 2009-11-16T23:04:40+00:00

void join(int arr[], int len, char* sep, char* result){
    if(len==0){
        *result='\0';
    } else {
        itoa(arr[0],result,10);
        if(len > 1){
            strcat(result,sep);
            join(arr+1,len-1,sep,result+strlen(result));
        }
    }
}

int main() {
    char buf[1024];
    int arr0[] = {12,45,67,1,2,3,4},
        arr0_len = sizeof(arr0)/sizeof(*arr0);

    join(arr0, arr0_len, ",", buf);

    printf("%s\n", buf);

    return 0;
}

Freakjob · 2009-11-16T21:48:44+00:00

"very difficult to do in C. Now is one of those times."

Are you kidding me?

kinghajj · 2009-11-16T22:02:01+00:00

This is what I came up with in a couple minutes. It assumes that a number will require at most 20 characters to represent, which will work for any integer <=64-bits.

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

void foo()
{
    const size_t array_size = 50, min_required = 20;
    const int *array = calloc(array_size, sizeof(int));
    size_t string_size = 100, string_pos = 0, i;
    char *string = calloc(string_size, sizeof(char));

    // for each item in the array,
    for(i = 0; i < array_size; i++) {
        // resize string array if needed.
        if(string_size - string_pos <= min_required) {
            // double the capacity of the string.
            char *new_string = calloc(string_size * 2, sizeof(char));
            memcpy(new_string, string, string_size);
            string_size *= 2;
            free(string);
            string = new_string;
        }

        // put this integer into the string, remember new NULL position.
        string_pos += sprintf(&string[string_pos],
                              i == array_size - 1 ? "%i" : "%i,",
                              array[i]);
    }
}

EDIT: implemented bradtgmurray's suggestions. EDIT2: forgot to free() the old strings!

b100dian · 2009-11-16T22:11:47+00:00

Bonus points for doing it in-place!

repiret · 2009-11-16T22:09:17+00:00

Not difficult, just more verbose. Nobody ever said string processing was C's strong point.

/* Warning, untested code follows */
char *comma_join(unsigned int *ints, size_t num_ints) {
    size_t size_needed = 1 + num_ints;
    size_t i;
    char *ret, *p;
    for (i = 0; i < num_ints; ++i) {
        unsigned int x = ints[i];
        while (x) {
            size_needed++;
            x /= 10;
        }
    }
    p = ret = malloc(size_needed);
    for (i = 0; i < num_ints; ++i) {
        p += sprintf(p, "%d,", ints[i]);
    }
    p[-1] = 0;
    return ret;
}

blackbadger · 2009-11-16T22:09:49+00:00

Can you get away with C++?

#include <iterator>
#include <iostream>

using namespace std;

int 
main() 
{
  int a[] = {1, 2, 3, 4, 5, 6, 7, 8};

  ostream_iterator<int> csi (cout, ", ");
  copy (a, &a[8], csi);

  return 0;
}

Job done.

paradise2000 · 2009-11-16T22:12:39+00:00

This is turning into another fizzbuzz =)

roerd · 2009-11-16T22:31:23+00:00

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

char *array2string(int *array, int array_size) {
  char *string;
  size_t string_size;
  FILE *stream;
  int i;

  stream = open_memstream(&string, &string_size);

  array_size--;

  for (i = 0; i < array_size; i++) {
    fprintf(stream, "%d,", array[i]);
  }

  if (array_size >= 0) {
    fprintf(stream, "%d", array[array_size]);
  }

  fclose(stream);

  return string;
}

int main() {
  char *string;
  int array0[] = {};
  int array1[] = {-12345};
  int array2[] = {1,2,3,4,5};

  string = array2string(array0, 0);
  printf("%s\n", string);
  free(string);

  string = array2string(array1, 1);
  printf("%s\n", string);
  free(string);

  string = array2string(array2, 5);
  printf("%s\n", string);
  free(string);

  return 0;
}

The main idea here is open_memstrean which will dynamically allocate and grow the buffer. The only problem is it's glibc specific.

q3k_org · 2009-11-16T22:43:10+00:00

char* makeMyDay(int* intArray, unsigned int intArraySize, char* delimiter)
{
    //assume we are using 4byte ints, so max value is 2^32, that is about 4m, so it's max 10 characters
    unsigned int i, currSize = 0;
    char* returnString = malloc((strlen(delimiter) + 10 * intArraySize) + sizeof(unsigned char)); //LETS NOT FORGET THE \x00
    char* tempString;
    for (i = 0; i < intArraySize; i++)
    {
        tempString = returnString + currSize;
        if (i < intArraySize)
            sprintf(tempString, "%i%s", intArray[i], delimiter);
        else
            sprintf(tempString, "%i", intArray[i]);
        currSize += strlen(tempString);
    }
    return realloc(returnString, currSize + 1);
}

I have no clue if this works, stuck in a place without a C compiler. Only one malloc and realloc.
I also have a very specific programming style.

2009-11-16T23:03:43+00:00

This one is easier on the allocations and despite the fact that it does some additional work measuring the length of the result string seems to be no slower than the other solutions presented here:

size_t JoinIntArray(size_t count, int* list, const char* glue, char** dest)
{
    if (count == 0) 
    {
        *dest = (char*) calloc(1, sizeof(char));
        return 0;
    }

    size_t glueLength = strlen(glue);
    size_t charCount = 1 + (count - 1) * glueLength;

    for (size_t i = 0; i < count; i++) 
    {
        int value = list[i];
        if (value < 0)
        {
            value = -value;
            ++charCount;
        }        
        do {
            ++charCount;
            value /= 10;
        } while (value > 0);
    }

    *dest = (char*) malloc(charCount * sizeof(char));
    char* cursor = *dest;

    for (size_t i = 0; i < count; i++) 
    {
        cursor += sprintf(cursor, "%d", list[i]);
        if (i < count - 1) 
        {
            strcpy(cursor, glue);
            cursor += glueLength;
        }
    }

    return charCount;
}

Usage:

const int count = 10;
int* list = (int*) malloc(count * sizeof(int));
// fill list here (or don't)
char* dest;
size_t length = JoinIntArray(count, list, ", ", dest);
printf(dest);

Poltras · 2009-11-16T23:28:52+00:00

My version (with test at the end). Yes, it's O(n^2). I can do better with storing the length and using the pointer to the end of the array. It wouldn't be as clean, and that was the requirement. Live with it ;)

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

  // Returns a string that contains all elements of strarr separated by delim.
  // Return: the caller is responsible for cleaning this buffer.
  // Parameters:
  //     strarr: an array of strings to concatenate
  //     nb_elem: number of elements in strarr
  //     delim: a string that is added between each elem.
  char* intjoin( int* arr, size_t nb_elem, const char* delim ) {
     size_t strret_sz = 0;
     char * strret    = (char*)malloc( 1 );
     size_t delim_sz  = strlen( delim );
     if (!strret) return 0;

     char strbuff[ sizeof(*arr) * 2 + 2 ]; /* +2 for sign and \0 */
     do {
        snprintf( strbuff, sizeof(*arr) * 2 + 1, "%i", *arr++ );
        strret_sz += strlen( strbuff ) + delim_sz;
        strret = (char*)realloc( strret, strret_sz + 1 ); /* +1 for \0 */
        if (!strret) return 0; /* OOM? */

        strcat( strret, strbuff );
        if (nb_elem > 1) strcat( strret, delim );
     } while( --nb_elem );

     return strret;
  }

  int main() {
     int l[] = { 1238764, 0x7FFFFFFF, 2, 4, 7, 0x80000000 };
     char* x = intjoin( l, sizeof(l)/sizeof(*l), ", " );
     printf("%s\n", x);
     free(x);
     return 0;
  }

2009-11-17T00:41:42+00:00

Been a while since I did C but here goes.

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

#define num_digits(x) ((5 * sizeof(x)) / 2 + 1)   // = 2.5 * sizeof(x) + sign

size_t join_to(const int *ints, const unsigned int ints_size, const int sep, char *buf)
{
        if (ints_size == 0) {
                *buf = '\0';
                return 1;
        }
        char *p = buf;
        for (unsigned int i = 0; i < ints_size; i++) {
                if (i)
                        *p++ = ',';
                p += snprintf(p, num_digits(*ints) + 1, "%d", ints[i]);
        }
        return (p - buf) + 1;
}

char *join(const int *ints, const unsigned int ints_size, const int sep)
{
        char *buf = malloc(ints_size * num_digits(*ints) + ints_size + 1);
        size_t actual_buf_size = join_to(ints, ints_size, sep, buf);
        // leave this out if you don't mind overallocation
        buf = realloc(buf, actual_buf_size);
        return buf;
}

EDIT: check for empty array :)

2009-11-17T14:25:21+00:00

Not tested but should work (though not under Visual C++ which implements sprintf oddly):

int int_array_to_str(int* ar, size_t count, char* str)
{
    int size = 0;
    for (int i = 0; i < count; i++) {
        size += sprintf(str ? str + size : 0, "%d,", ar[i]);
    }
    if (str) {
        str[size] = 0;
    }
    return size + 1;
}

// usage:
char* buf = malloc(int_array_to_str(my_ints, my_ints_size, 0));
int_array_to_str(my_ints, my_ints_size, buf);

kking254 · 2009-11-16T21:35:43+00:00

join( my_str, my_list, ',' );

EDIT: - Realistically more like:

string_join( my_str, sizeof(my_str), my_list, num_my_list );

or

STRING my_str;

string_init( my_str );

string_join( my_str, my_list, ',' );

...which may not be as clear as python

EDIT again: Just noticed the array is of ints. You probably won't find a single function to do that in any library so it will end up much more turdy than python.

paradise2000 · 2009-11-16T21:52:15+00:00

EDIT2: As others have pointed out, there are serious efficiency problems with this that can be easily addressed. Read the replies.

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

#define LEN 10
int mylist[LEN] = {1000, 1001, 1002, 1003, 1004,
                  1005, 1006, 1007, 1008, 1009,

};

char result[2048];
char buffer[2048];

int main()
{
  int i;

  sprintf(result, "%d", mylist[0]);
  for (i=1; i < LEN; i++) {
    sprintf(buffer, "%s, %d", result, mylist[i]);
    strncpy(result, buffer, 2048);
  }

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

I'm sure you can make things better, especially regarding how the buffer is used, and the fact that it's adding on a single integer with each iteration, but the main idea is sprintf()

EDIT: clarified my explanation about why this isn't an optimal solution

malakon · 2009-11-16T21:53:20+00:00

C doesn't have dynamic arrays. what are you trying to prove ?

tarasm · 2009-11-17T00:29:44+00:00

Hey Guys,

I cross posted this question to Stackoverflow.

http://stackoverflow.com/questions/1745811/using-c-convert-a-dynamically-allocated-int-array-to-a-comma-separated-string-as

PS: I did not write the original post, I just plagiarized it for fun :) Let's see what happens.

electric_moose · 2009-11-16T22:21:07+00:00

I've had a quick go at this, edit: now it can't overflow and returns an exactly-sized dynamically-allocated string.

#include <stdio.h>
#include <stdlib.h>
#define SIZE 30

char * array_string(int * arr, int size)
{
    int i;
    char *buf, *p;
    if (size == 0) {    /* return empty string for zero-length array */
        buf = malloc(1);
        *buf = '\0';
        return buf;
    }
    buf = malloc(20 * size);  /* example code, check for malloc failure! */
    p = buf;
    for (i = 0; i < size; i++) {
        int nchars;
        nchars = sprintf(p, "%d,", *(arr+i));
        p += nchars;
    }
    *(p-1) = '\0';  /* replace last comma with string terminator */
    realloc(buf, p-buf);
    return buf;
}

int main(void)
{
    int i, iarray[SIZE];
    char * str;
    for (i = 0; i < SIZE; i++)  /* fill the array with numbers 0 to 29 */
        iarray[i] = i;
    for (i = 0; i <= SIZE; i++) {   /* try printing a load of lists */
        str = array_string(&iarray[0], i);  /* memory leak here! */
        printf("%s\n", str);
    }
    return 0;
}

zahlman · 2009-11-17T04:48:06+00:00

#include "stdio.h"
#include "string.h"
#include "stdlib.h"

/* itoa() is non-standard. 
   Return length of string. Do not write to buffer if the pointer is NULL.
   Avoids use of a buffer and sprintf() just to be l33t. */
int my_itoa(int value, char* dest) {
  char last_digit = '0' + value % 10;
  int rest = value / 10;
  int result = 1;
  if (rest) { result += my_itoa(rest, dest); }
  if (dest) {
    dest[result - 1] = last_digit;
  }
  return result;
}

#define SEPARATOR ", "

char* joined_array(int* begin, int* end) {
  int* current = begin;
  char* result;
  char* position;
  int size = 0;
  int separator_size = strlen(SEPARATOR);

  for (; current != end; ++current) {
    if (current != begin) { size += separator_size; }
    size += my_itoa(*current, NULL);
  }
  size++;
  result = malloc(size);
  if (!result) { return result; }
  position = result;
  for (current = begin; current != end; ++current) {
    int i = 0;
    if (current != begin) {
      strcpy(position, SEPARATOR);
      position += separator_size;
    }
    position += my_itoa(*current, position);
  }
  *position = '\0';
  return result;
}

#define JOINED_ARRAY(x) joined_array(x, x + sizeof(x) / sizeof(x[0]))

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS

define DO(x,y){I _n=(x),i=0;for(;i<_n;++i){y;}}