Définir une nouvelle fonction, un tableau, une structure, etc. à l’intérieur du paramètre de l’appel de fonction

Si vous aviez une fonction qui prenait les choses suivantes:

void foo(char **arr); 

Comment pouvez-vous faire ce qui suit:

 void foo(char* x[] = { "hello", "my", "friend" }); 

Si cela vous déroute, en Java, nous procédons comme suit:

 public void foo(Ssortingng[] x); foo(new Ssortingng[] { "hello", "my", "friend" }); 

Actuellement, je fais ce qui suit en C, ce que je déteste parce que ça a l’air vraiment moche:

 char* myArr[] = { "hello", "my", "friend" }; foo(myArr); 

    Comment pouvez-vous faire ce qui suit:

     void foo(char* x[] = { "hello", "my", "friend" }); 

    Vous avez presque réussi … 😉

    Si vous utilisez C99 ou une version plus récente, utilisez un littéral composé comme celui-ci:

     foo((char *[]){"hello", "my", "friend"}); 

    Notez que la fonction appelée ( foo() here) n’a aucune idée du nombre d’éléments contenus dans le tableau de pointeurs. Vous souhaitez donc append un pointeur null final en tant que sentinel:

     foo((char *[]){"hello", "my", "friend", NULL}); 

    Exemple:

     #include  #include  /* for EXIT_xxx macros */ void foo(char **arr) { while (arr && *arr) { printf("%s\n", *arr); ++arr; } } int main(void) { foo((char *[]){"hello", "my", "friend", NULL}); /* Mind the final NULL. */ return EXIT_SUCCESS; } 

    Cela va imprimer:

     hello my friend 

    Le littéral composé est valide jusqu’à ce que le domaine dans lequel il a été défini soit laissé ( main() ici). Si vous voulez vous assurer qu’il est supprimé de la stack immédiatement après son utilisation, mettez des accolades autour de l’appel à foo() créant une scope / un bloc local:

     int main(void) { { foo((char *[]){"hello", "my", "friend", NULL}); /* Mind the final NULL. */ } /* The compound literal passed to foo() is already deallocated here, had been removed from the stack. */ ... 

    Java et C sont des langages différents avec des idiomes différents.

    Si c’était moi, je m’abstiendrais d’essayer [trop dur] de contraindre C à “ressembler à Java”. Emarmse chaque langue sur ses propres mérites.

    Pour votre premier exemple, celui “moche”, vous pouvez utiliser une macro CPP [préprocesseur C] – un concept qui n’existe pas en Java:

     #define FOO(_av...) \ do { \ char *myArr[] = { _av, NULL }; \ foo(myArr); \ } while (0) FOO("hello", "my", "friend"); 

    Mais cela serait probablement considéré par beaucoup comme “trop ​​mignon”. Mieux vaut créer une table de quelque sorte.

    Chaque fois que Java fait un new il fait une allocation de tas [ce qui est lent]. C’est en partie parce que tout doit être “sur le tas”, plus ou moins.

    C peut le faire avec malloc , mais un bon programmeur C tentera d’éviter les allocations de tas inutiles car il contient des variables globales, statiques et à fonctions étendues.

    Vous devez être juste une autre victime des personnes qui commencent par java , puis essaient d’entrer dans c , c’est pourquoi je vais répondre.

    Je veux initialiser mon tableau à l’intérieur de ce paramètre. Comment cela peut-il être fait?

    Vous ne pouvez pas. avant C99


    En général, c’est quelque chose que vous pourriez faire:

     #include  void foo(char** arr, int size) { int i; for(i = 0; i < size; ++i) printf("%s\n", arr[i]); } void bar(char** arr) { while(*arr) printf("%s\n", *arr++); } int main(void) { char* x[] = { "hello", "my", "friend" }; foo(x, 3); char* null_terminated[] = { "ShadowRanger", "Correct", NULL }; bar(null_terminated); return 0; } 

    foo() utilise explicitement la taille du tableau, tandis que bar() nécessite que le tableau soit terminé par NULL.