string array in c

Question

Comment utilisez-vous un tableau de chaînes en tant que paramètre dans C? Si je devais écrire une fonction avec la signature:

Devinez je ne me suis pas très bien expliqué ... Je posterai le code que j'essaye de mettre au travail.

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

Il devrait y avoir un deuxième (et troisième?) Paramètre dans la signature format_parameters, un char* param[5] qui doit être lisible à partir main.

Answer 1

Est-ce que cela fonctionne?

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

La valeur de retour est le nombre de paramètres trouvés. Si vous passez une chaîne vide, ce serait 0. Méfiez-vous des blancs de début, de fin et répétés; le code fonctionne - mais peut-être pas comme vous le voulez.

Answer 2

Ceci concerne entièrement l'allocation de mémoire.

Si vous allouez de la mémoire statique pour param avant l'appel de la fonction, la mémoire existera dans cette portée. Sinon, jetez un oeil à l'allocation dynamique, il existera jusqu'à ce que vous lui disiez de partir.

Answer 3

Comme Jonatahan a souligné, vous avez besoin de plusieurs paramètres:

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

paramOutput est un tableau de pointeurs. Ainsi, l'appelant doit fournir un tableau de pointeurs et la fonction appelée doit allouer de la mémoire pour les chaînes et définissez les pointeurs dans le tableau:

// 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 4

Vous devez créer le tableau char * param [] en dehors de la fonction et juste passer comme paramètre:

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

et à l'intérieur de la fonction:

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++; 
    ............. 
} 

et afin d'écrire du code de sécurité, vous devez aussi passer le paramCount en tant que paramètre format_parameters pour que la fonction n'accède pas à un élément hors des limites du tableau.

Ou peut-être vous devriez simplement utiliser getopt?