How to add commas into a char array in C

Question

So I have a char array that currently holds a struct of a person's information. For example,

struct Person{
char first_name[100];
char last_name[100];
char phone[13];
};

struct Person* arr[] = {("John", "Doe", "831.563.3642"), ("Julie", "Dee", "542.865.4644") };

And I am trying to have it end up printing to a file to look like this...

John, Doe, 831.563.3642
Julie, Dee, 542.865.4644

So far this is the code I have (to try and add the commas while putting into a file)

void print(FILE* file_out, struct Person* p1[]){
   size_t len = sizeof(p1) / sizeof(p1[0]);
   for(i = 0; i < len; i++){
      fprintf(file_out, "%s, %s, %s\n", p1[i].first, p1[i].last, p1[i].phone);
   }
}
return;

Answer 1

struct Person* arr[1] is equivalent to Person arr is also equivalent to Person** arr I don't think that is what you meant. get rid of the pointer :D

Now some really important things about strings... The strlen function is the #1 reason for buffer overflow bugs - NEVER use strlen without some kind of limitation.

Also, internally string length looks like this...

int strlen(char* str) {
    int count = 0;
    while (str[count]) {
        count++;
    }
    return count;
}

notice that is almost your function? Your function could be changed to...

char* makeString(char* str) {
    char out[] = ""
    int count = 0;
    while (str[count]) {
        out[count] = str[count];
        count++;
    }
    out[count] = ',';
    out[count + 1] = 0;
    return out;
}

Lets talk about the major problems with this though - first, notice the while loop that only ends when it finds a 0? That is a GREAT way to make a bug. All somebody has to do is give a name just a little too long and boom! there is no ending 0.

Now imagine I call your function multiple times in a row... You are looping through the string each time!!! In other words, I iterate through the loop for the string "john". that is 4 times through the while loop. it also makes a char[6] to hold those things - since john is 4, and the ',' is 1, and the "end of the string" marker is a 0.

Now we add to the string again. we iterate over "john" the ",", and add "Joe". This means we need a new longer char[] of length 9. now we iterate over "john, " and "doe" for 9 while loop hits. Then we do this again and again. We iterate over john a HUGE number of times. Way too many times.

Now for the safe way to do this :D

//Create a string of a known length that can hold all the data
//Now we only need to create a char buffer once instead of multiple times
//In a regular computer, it is better to waste space than CPU time :D (in this case anyway...)
char printString[sizeof(arr.first_name) + 2 + sizeof(arr.last_name) + 2 + sizeof(arr.phone) + 1];
//Remember where we last wrote, and where we are in our current copy
int position = 0;
int i = 0;
//While it is not the end of the string, and we have not gone over the longest possible length...
while (arr[0].first_name[i] && i < sizeof(arr[0].first_name)) {
    //Copy the character
    printString[position] = arr.first_name[i];
    //Move to the next spot in both character buffers
    position++;
    i++;
}
//Add our comma and space
prinstString[position] = ',';
printtString[position + 1] = ' ';
position = position + 2;
int i = 0;
while (arr[0].last_name[i] && i < sizeof(arr[0].last_name)) {
    printString[position] = arr.last_name[i];
    position++;
    i++;
}
prinstString[position] = ',';
printtString[position + 1] = ' ';
position = position + 2;
int i = 0;
while (arr[0].phone[i] && i < sizeof(arr[0].phone)) {
    printString[position] = arr.phone[i];
    position++;
    i++;
}
prinstString[position] = 0;

Now for the benefits.

We only iterate through each string once. This avoids the problem above where we iterate over John a million times. (Look here to see a funny way to see it XD)

The biggest benefit is checking that we have not gone over the end. Nobody can exploit out strings anymore!!!

And also, we only need to alocate a char buffer ONCE to hold all this cumulative string concatenation stuff.

We also have some really nice information for the next guy if we wanted to pass it on, and notice it almost is the form of an algo? How awesome - it can almost be a function!

Now for the grand finale! All of that hard work has been done by someone so much smarter than both of us ;)

printf("%s, %s, %s", arr[0].first_name, arr[0].last_name, arr[0].phone);

I think I am done editing now!!

Answer 2

You may be making things way harder on yourself than you need to. With your struct Person filled, in order to obtain the output you need, you simply need to output the struct members separated by a comma and space. A simple printf will do, e.g.

struct Person p1 = { "John", "Doe", "831.563.3642" };
...
printf ("%s, %s, %s", p1.first, p1.last, p1.phone);

The output from above would be:

John, Doe, 831.563.3642

You can never do char new[] = ""; -- which creates the array new of size 1 holding the '\0' character. (bad choice of names as well, new is a kewword in C++, its use as a variable name should be avoided). Once you declare and initialize the array with automatic storage duration of size 1 -- it's size is FIXED -- period, and cannot be expanded. You would need to dynamically allocate storage with malloc in order to be able to resize the storage later with realloc.

If you want to create an additional array holding the comma separated values, then you need to declare the array with storage to hold the largest first_name, last_name and phone initially, e.g. char buf[100 + 100 + 13 + 4]; (the +4 for the pair of ", " you want to insert as well) Now you can use sprintf to simply write to the new array.

Below is a short example which shows both the direct output with printf and the creation of a new array (buf) using sprintf. The results is the same regardless of whether you directly output the comma space separated values, or store them in a buffer first. The function csvperson() takes the destination array and a pointer to a filled struct as parameter to write the members of the struct separated by a comma and space to array, e.g.

#include <stdio.h>

#define MAXNM 100   /* if you need a constant, #define one (or mroe) */
#define MAXPH  13

typedef struct {            /* using a typedef allows you to later omit the */
    char first[MAXNM],      /* 'struct' prefix in your declarations and */
         last [MAXNM],      /* parameter lists */
        phone [MAXPH];
} person;

char *csvperson (char *dest, person *p)
{
    if (!dest)
        return NULL;

    sprintf (dest, "%s, %s, %s", p->first, p->last, p->phone);

    return dest;
}

int main (void) {

    char buf[2 * MAXNM + MAXPH + 4];
    person p1 = { "John", "Doe", "831.563.3642" };

    printf ("direct output : %s, %s, %s\nbuffer output : %s\n", 
            p1.first, p1.last, p1.phone, csvperson (buf, &p1));
}

Example Use/Output

$ ./bin/csvperson
direct output : John, Doe, 831.563.3642
buffer output : John, Doe, 831.563.3642

Look things over and let me know if you have further questions.

---

Array Example

To use the same methods above with an array, you would do:

int main (void) {

    char buf[2 * MAXNM + MAXPH + 4];
    person p1[] = { {"John", "Doe", "831.563.3642"},
                    {"Jane", "Doe", "832.563.3643"},
                    {"Mary", "Jane", "303.331.3333"} };
    int n = sizeof p1 / sizeof *p1;

    for (int i = 0; i < n; i++)
        printf ("\ndirect output : %s, %s, %s\nbuffer output : %s\n", 
                p1[i].first, p1[i].last, p1[i].phone, csvperson (buf, p1+i));
}

You can simply use fprintf to output to a file without buffering the output first, e.g.

fprintf (fileptr, "%s, %s, %s\n", p1[i].first, p1[i].last, p1[i].phone);

In general, don't worry about combining/concatenating/etc.. things you can simply write out (wherever be it a file, the terminal, etc..)