string array in c

Question

How do you use a string array as a parameter in C? If I were to write a function with signature:

Guess i didnt explain myself very well... I'll post the code that i'm trying to get to work.

int format_parameters(char* str) {

    char local_str[201] = "";
    int i = 0;
    int j = 0;
    int flip = 0;

    while(str[i]) {

        if((str[i] == '"') && (flip == 0)) flip = 1;//Sentence allowed
        else if((str[i] == '"') && (flip == 1)) flip = 0;//Sentence not allowed

        if(flip == 1) append_char(local_str, str[i]);
        //check if space
        else if(flip == 0) {

            int c = str[i];
            if(!isspace(c)) append_char(local_str, str[i]);

            else {
                if((strlen(local_str) > 0) && (j < 4)) {
                    //local-str copied to param[j] here
                    //printf("j = %d %s\n",j,local_str);

                    local_str[0] = '\0';
                    j++;
                }
            }
        }
        i++;
    }

    //Add \0 to param

    return flip;
}//end format_parameters


void append_char(char* str, char c) {
    int len = strlen(str);
    str[len] = c;
    str[len+1] = '\0';
}//end append_char

int main() {
        char str[200];
        //str filled with stuff...
        int x = format_parameters(str);
}

There should be a second (and third?) parameter in format_parameterssignature, a char* param[5] which should be readable from main.

Answer 1

As Jonatahan pointed out, you need more parameters:

int format_parameters(char* strInput, char* paramOutput[], size_t cbMaxParams );
// return value is actual number of parameter strings in paramOutput

paramOutput is an array of pointers. So the caller has to provide an array of pointers and the called function has to allocate memory for the strings and set the pointers in the array:

// main:
#define SIZE 20
char * params[SIZE];

int result = format_parameters( szInput, params, SIZE );
// after use go through params and free all pointers 

// function:
int format_parameters(char* strInput, char* paramOutput[], size_t cbMaxParams )
{
  // ...

  for( size_t i=0; (i<cbMaxParams) && (!noMoreParams); i++ )
  {
     // ... 
     paramOutput[i] = (char *)malloc( xxxx );
     // ...
  }

  // ...
}  

Answer 2

You have to create the char* param[] array outside the function and just pass it as a parameter:

int paramCount = countParameters(str);  // you have to create this function
char* param[] = malloc(paramCount * sizeof(char*));
format_parameters(str, param);

and inside the function:

int format_parameters(char* str, char* param[])
{
    int currentParamIndex = 0;

    ..........
        //TODO: check if currentParamIndex < paramCount
        char* currentParam  = str + currentParamStart; // currentParamStart is the start index of the parameter in the str containing all parameters
        param[currentParamIndex] = currentParam;
        currentParamIndex++;
    .............
}

And in order to write safe code you have to pass also the paramCount as a parameter to format_parameters so the function will not access an element out of the bounds of the array.

Or maybe you should just use getopt?

Answer 3

Does this work?

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

int format_parameters(char *str, char *param[], size_t nparam)
{
    char **next = param;
    char **end  = param + nparam;
    char  *data = str;

    assert(str != 0 && param != 0 && nparam != 0);

    while (next < end && *data != '\0')
    {
        *next++ = data;
        data = strchr(data, ' ');   // Choose your own splitting criterion
        if (data == 0)
            break;
        *data++ = '\0';
    }
    return(next - param);
 }

 int main(void)
 {
     char  str[] = "a b c d";
     char *param[5];
     int   nvals = format_parameters(str, param, 5);
     int   i;

     for (i = 0; i < nvals; i++)
         printf("Param %d: <<%s>>\n", i+1, param[i]);

     return 0;
  }

The return value is the number of parameters found. If you pass an empty string, that would be 0. Beware leading, trailing and repeated blanks; the code works - but maybe not as you want it to.

Answer 4

This is entirely about memory allocation.

If you allocate static memory for param before the function is called, the memory will exist in that scope.

Otherwise take a look at dynamic allocation, it will exist until you tell it to go away.