Salut
Je fais une consol avec des lignes de commande et je souhaite décomposer les valeurs entré
par exemple

!o pen(test.jpg)

la la consol verra !o pen puis tombera sur un ( la il prend en compte tout ce qu´il y a entre les deux parenthése et fais sont boulot

Mais comment faair pour decortiquer la commande ? j´ai beau me casser la tête je ne trouve pas ! =(

Merci d´avane

int main(int ac, char **av)

ac = nb d argument ( comprend le nom de l´executable)

• • av pour acceder aux argument

av[0] ... str du premier argument
av[0][0] premiere lettre du premier argument...

apres tu prend l´argument pen() ( av[2] je supose... )

tu fais une boucle qui va jusqu au premier ´(´ puis tu copie ta ton test.jpg jusqu au ´)´

ca me parait peu utilisé se genre de commande... avec des parenteses... mais c est un bon exercice....

escuse moi d´étre chiant et particulierement nul mais je comprend pas c´est quoi un "argument" ?

Et si tu pouvait me donner un extrait de code utilisant sa (comme sa je comprend mieux moi^^)

Merci et encore dsl mais j´apprend encore ^^

T´as commande c´est !o pen(test.jpeg) ou !o pen(test.jpeg) ?

Qu´est-ce qui doit être reconnu exactement comme mot dans cette commande? Quelles parties exactement doivent être décortiquées ?

Un argument, c´est ce que l´on passe au programme principale quand on l´éxécute. Un peu comme quand tu passes des paramètre à une fonction, sauf que la c´est passé à la fonction "main" (voir le post de enfertiede).

Ma commande c´est !o pen(test.jpeg)
Et ce qui doit étre reconnu c´est le !o pen puis la "(" il prendra tout ce qu´il y a aprés la "(" jusqua la ")"

Toutes les données seront reutiliser dans des fonctions qui ouvrirons test.jpeg

Et merci j´ai mieux compris ce qu´est un argument =)

Alors si tu dois juste récuperer ces 2 parties, tu peux le faire avec la fonction "strtok". Cette fonction prend en paramètre une string (lors du premier appel) et une chaine de délimiteurs (dans donc cas c´est "()");
Tu apelle cette fonction avec ces 2 paramètre la première fois. Elle va te renvoier "!o pen".
Pour le 2ème appel, tu passe NULL pour le premier argument (qui avant était ta string). En fait, ça sert à dire qu´on travaille toujours sur la même string mais un mot plus loin ;- ). (Tu passe toujours les meme délimiteurs). Tu recevra ainsi la 2e partie comme string.

Et voila J´espère avoir été assez clair.

´est deja bcp plus clair !

J´ai essayer par moi même mais j´ai bcp de mal donc si quelquin pouvait me donner un bout de code source pour que je voit concretement comment sa marche sa m´aiderais beaucoup

merci de vos reponsse :D

Je vais essayer de te faire un bout de code ;- ).
Donc nous voici au moment où tu as reçu ce que l´utilisateur à tappé au clavier, avec la fonction fgets j´imagine :

...

char maString[256];
fgets(maString, 255, stdin);
/* Decoupons maintenant */
char delimiteurs[] = {´(´,´)´};
char * monToken; /* Un token est un résultat renvoyé par la fonction strtok */

monToken = strtok(maString, delimiteurs);
char * premierMot = (char *)malloc(strlen(monToken) * sizeof(char));
strcpy(premierMot, monToken);

monToken = strtok(NULL, delimiteurs);
char * deuxiemeMot = (char *)malloc(strlen(monToken) * sizeof(char));
strcpy(deuxiemeMot , monToken);

/* Et voila on a nous 2 parties ! */
/* Il faudra inclure les bonnes librairies pour cela, recherche sur google ! */
/* Je pense que string.h et stdio.h suffiront */
/* Peut etre stdlib.h */

ok merci c´est compris
Je vais pouvoir complexifier tout ca maintenant <.<

Merci beaucoup !

Juste une derniére question sa marche si on utilise scanf plutot que fgets ?

oh et puis je vais tester moi même merci

j´ai un peut modifier le code:

1. include <stdio.h>
2. include <stdlib.h>
3. include <string.h>
4. include <malloc.h>

int main(int argc, char *argv [])
{

char maString[256];
fgets(maString, 255, stdin);
printf("%s 1\n", maString);
/* decoupage */

char delimiteurs[50] = {´(´,´)´};
char * monToken;

printf("%s 2\n", maString);
monToken = strtok(maString, delimiteurs);
printf("%s 3\n", maString);
char premierMot[256];
strcpy(premierMot, monToken);
printf("%s 4\n", maString);
printf("%s : %s : %s\n", premierMot, monToken, maString);
system("PAUSE");
return 0;
}

Il marche trés bien sauf que l´on ne recupére pas
ce qu´il y a entre les parenthése et j´ai beau me casser la téte a modifier ceci et cela je ne trouve point :/

Normal, tu ne demande à aucun moment le token correspondant à ce qu´il ya entre les 2 parenthèses. Tu demande le premier mot jusqu´à ce qu´une parenthèse (ouvrante ou fermante) soit détectée, mais tu ne demande pas ensuite à nouveau le prochain mot détecté jusqu´à découverte d´un parenthèse ou fin de string.

-> strtok(NULL, delimiteurs)

1. include <stdio.h>
2. include <stdlib.h>
3. include <string.h>
4. include <malloc.h>

int main(int argc, char *argv [])
{

char maString[256];
fgets(maString, 255, stdin);
printf("%s 1\n", maString);
/* decoupage */

char delimiteurs[] = "()";
char * monToken;

printf("%s 2\n", maString);
monToken = strtok(maString, delimiteurs);
printf("%s 3\n", maString);
char premierMot[256];
strcpy(premierMot, monToken);
char deuxiemeMot[256];
monToken = strtok(NULL, delimiteurs);
strcpy(deuxiemeMot, monToken);
printf("%s 4\n", maString);
printf("1: %s \n2: %s \n3: %s\n", premierMot, deuxiemeMot, maString);
system("PAUSE");
return 0;
}

Voila.
Pour tes délimiteurs, tu prévoyais 50 cases en mémoire dés le départ, alors que seulement 2 étaient utilisées => mieux vaut ne pas donner le nombre de cases dans ces cas là. (Au pire dans ton cas, la fin de la string est completé par des ´\0´, donc le caractère de fin de string. Si je ne me trompe pas).
Sinon , j´ai juste ajouté le deuxième mot et ça fonctionne ;- ).

ah ok!
J´avais pas trop bien comment marche strtok

Merci encor j´ai fais quelques test et sa marche trés bien ;)