Forums Rue-Montgallet.com
Rue-Montgallet.comRue-Hardware.comRue-Occasion.comRue-DVD.comRue-Jeuxvideo.comRue-AudioVideo.comRue-Telephone.comForums
S'inscrire | S'identifier |
| Recherche avancée | Aide
 

  FORUM


  Programmation


  C - C++


  Passage de paramètre en C

 
 

kazer Achat - Vente Informatique : kenta2 Achat - Vente Divers : Elokenz, tylerdurden0, ngu et 77 utilisateurs inconnus

 Mot :   Pseudo :  
 
Bas de page
Auteur
 Sujet :

Passage de paramètre en C

 
n°10449
linbeg
Profil : Jeune recrue
Posté le 14-10-2004 à 13:53:07  profilanswer
 

Je souhaiterais appliquer à l'une de mes fonctions la même méthode que dans le main
 
int main(int argc, char *argv[])
 
C'est à dire récupérer chaque chaine de caractères et le nombre d'arguments passés. Suis-je obligé de faire un system() pour relancer un autre main ou y a t-il une autre solution.
 
Exemple : j'ai une ligne de commande l'utilisateur tape quelque chose et je veux faire comme si j'étais sous DOS en fait c'est à dire récupérer les arguments et le nombre
 
Merci d'avance

n°10450
nico95
A la poursuite du SMS Staÿle
Profil : Dinosaure
Posté le 14-10-2004 à 14:30:09  profilanswer
 

linbeg a écrit :

Je souhaiterais appliquer à l'une de mes fonctions la même méthode que dans le main
 
int main(int argc, char *argv[])
 


int fonction(int argc, char *argv[])  
:spamafote: je vois pas ou est le probleme ..

n°10451
linbeg
Profil : Jeune recrue
Posté le 14-10-2004 à 15:08:40  profilanswer
 

nico95 a écrit :

int fonction(int argc, char *argv[])  
:spamafote: je vois pas ou est le probleme ..


NoN si tu préfère le main gère automatiquement les méthodes argv et argc qui son des mots clés.
Si je fais une fonction de type
fonction(argc, argv) il ne comprend pas ce que je veux dire!!
ça ne trouve pas automatiquement le nombre d'argument et ça ne les sépare pas automatiquement en les mettant chacun dans un tableau de pointeur de chaine.....
Pour l'instant j'ai trouvé une solution potable pour ceux que ça interessent. C'est de lancer l'exécution d'un autre programme c'est à dire créer un nouveau main!!!
Un peu chiant mais bon...
 :)

n°10452
nico95
A la poursuite du SMS Staÿle
Profil : Dinosaure
Posté le 14-10-2004 à 15:11:34  profilanswer
 

aaahhh ok ok ok ....
 
ta soluce, c'est un peu du rafistolage, nan ?

n°10453
P-Y
Intermittent du troll
Profil : Vieux de la vieille
Posté le 14-10-2004 à 16:10:14  profilanswer
 

Bah si t'appelles ta fonction directement depuis le main avec argc et argv comme arguments, ca devrait marcher non? :??:


Message édité par P-Y le 14-10-2004 à 16:10:35
n°10454
linbeg
Profil : Jeune recrue
Posté le 14-10-2004 à 16:30:04  profilanswer
 

P-Y a écrit :

Bah si t'appelles ta fonction directement depuis le main avec argc et argv comme arguments, ca devrait marcher non? :??:


 
Tu as raison, je pense que ça doit marcher mais c'est du rafistolage encore plus compliqué que le mien et dans mon cas il ne pourrait pas fonctionner, puisque mon programme démarre sur une identification, il n'y a pas de passage de paramètres. :pfff:  
 
Nico95 ==> C'est vrai que c'est un peu du rafistolage mais ça fonctionne bien et ça complique pas trop... :p

n°10456
P-Y
Intermittent du troll
Profil : Vieux de la vieille
Posté le 14-10-2004 à 17:11:18  profilanswer
 

linbeg a écrit :

Tu as raison, je pense que ça doit marcher mais c'est du rafistolage encore plus compliqué que le mien et dans mon cas il ne pourrait pas fonctionner, puisque mon programme démarre sur une identification, il n'y a pas de passage de paramètres. :pfff:  
 
Nico95 ==> C'est vrai que c'est un peu du rafistolage mais ça fonctionne bien et ça complique pas trop... :p


ah ok je comprends mieux :)
Bon ben t'as plus qu'a ecrire un mini parser de chaine de caractères :D

n°10459
podone
POD first ONE of best game
Profil : Habitué
Posté le 15-10-2004 à 21:38:20  profilanswer
 

Voici une solution possible :

Code :
  1. // ARG.cpp : définit le point d'entrée pour l'application console.
  2. //
  4. #include "stdafx.h"
  6. #include <windows.h>
  7. #include <string.h>
  9. // Taille de la ligne de saisie
  10. #define  USERCMDSIZE                   (256)
  12. // Caractere de separation de commandes
  13. #define  CMDSEPARATORCHAR              (' ')
  15. // Caractere de generation de chaine
  16. #define  MAKESTRINGCHAR                ('\0')
  19. // Structure de commande utilisateur
  20. typedef struct _USERCMD
  21. {
  22.    int                  argc;          // Nombre d'entrees
  23.    char**               argv;          // Tableau des arguments
  24. }
  25. USERCMD;
  27. typedef USERCMD*                       LPUSERCMD;
  29. void MaFonction(int argc, char* argv[]);
  31. void P_GetUserCommand(LPUSERCMD  A_lpCmd);   // OUT
  33. void P_FreeCommand(LPUSERCMD  A_lpCmd); // OUT
  35. int _tmain(int argc, char* argv[])
  36. {
  37. // Commandes utilisateur
  38. USERCMD                 xUserCmd;
  40.    // Recuperer les commandes utilisateur
  41.    P_GetUserCommand(&xUserCmd);
  43.    // Les passer en argument de fonction
  44.    MaFonction(xUserCmd.argc, xUserCmd.argv);
  46.    // Liberer la memoire
  47.    P_FreeCommand(&xUserCmd);
  49.    // Encore une fois
  50.    P_GetUserCommand(&xUserCmd);
  52.    // Les passer en argument de fonction
  53.    MaFonction(xUserCmd.argc, xUserCmd.argv);
  55.    // Liberer la memoire
  56.    P_FreeCommand(&xUserCmd);
  58. return 0;
  59. }
  61. void MaFonction(int argc, char* argv[])
  62. {
  63. // DECLARATION DES VARIABLES LOCALES
  64. // Compteur de boucles
  65. int                     i;
  67. // TRAITEMENT
  68.    // POUR chaque commande
  69.    for (i = 0; i < argc; i++)
  70.    {
  71.       // Afficher la commande
  72.       printf("%s\n", argv[i]);
  73.    }
  74.    // FIN POUR
  76. } // fin MaFonction()
  79. void P_GetUserCommand(LPUSERCMD  A_lpCmd)    // OUT
  80. {
  81. // DECLARATION DES VARIABLES LOCALES
  82. // Ligne de commande
  83. char*                   lpszLineBuffer;
  85. // Commande
  86. char*                   lpszCmd;
  88. // Adresse de la commande
  89. char**                  lpCmdAd;
  91. // Resultat de fonction
  92. char*                   lpszApiResult;
  94. // Taille de la commande
  95. BYTE                    byCmdSize;
  98. // TRAITEMENT
  99.    // Initialiser le resultat
  100.    A_lpCmd->argc = 0;
  101.    A_lpCmd->argv = NULL;
  103.    // Reserver la memoire pour le buffer
  104.    lpszLineBuffer = (char*) malloc(USERCMDSIZE);
  106.    // Initialiser l'adresse de la premiere commande
  107.    lpszCmd = lpszLineBuffer;
  109.    // Recuperer les nouvelles commandes
  110.    lpszApiResult = gets(lpszLineBuffer);
  112.    // SI reussite
  113.    if (lpszApiResult)
  114.    {
  115.       // TANT QUE analyse en cours (cas aucune entrée ou dernier caractere est le caractère séparateur de commandes)
  116.       while (*lpszCmd)
  117.       {
  118.          // Rechercher la fin de commande
  119.          lpszApiResult = strchr(lpszCmd, CMDSEPARATORCHAR);
  121.          // Calculer la taille de la commande
  122.          byCmdSize = (BYTE)((size_t)lpszApiResult - (size_t)lpszCmd);
  124.          // Reserver la memoire pour la commande
  125.          A_lpCmd->argv = (char**) realloc(A_lpCmd->argv,
  126.                                           (sizeof(char*)) * (A_lpCmd->argc + 1));
  128.          // Actualiser l'adresse de la commande
  129.          lpCmdAd = A_lpCmd->argv + A_lpCmd->argc++;
  131.          // Allouer la memoire pour la commande
  132.          *lpCmdAd = (char*) malloc(byCmdSize + 1);
  133.        
  134.          // Recuperer la commande
  135.          memcpy(*lpCmdAd, lpszCmd, byCmdSize);
  136.          *(*lpCmdAd + byCmdSize) = MAKESTRINGCHAR;
  138.          // SI fin d'analyse
  139.          if (!lpszApiResult)
  140.          {
  141.             // Terminer le traitement
  142.             break;
  143.          }
  144.          // FIN SI
  146.          // Recuperer l'adresse du separateur de commandes
  147.          lpszCmd = lpszApiResult;
  149.          // FAIRE
  150.          do
  151.          {
  152.             // Actualiser le pointeur
  153.             lpszCmd++;
  154.          }
  155.          // TANT QUE separateur de commandes en cours
  156.          while (*lpszCmd == CMDSEPARATORCHAR);
  157.       }
  158.       // FIN TANT QUE
  159.    }
  160.    // FIN SI
  162.    // Desallouer le buffer
  163.    free(lpszLineBuffer);
  165. } // fin P_GetUserCommand()
  168. void P_FreeCommand(LPUSERCMD  A_lpCmd)  // OUT
  169. {
  170. // DECLARATION DES VARIABLES LOCALES
  171. // Compteur de boucles
  172. int                     i;
  174. // Adresse de la commande
  175. char**                  lpCmdAd;
  178. // TRAITEMENT
  179.    // POUR chaque commande
  180.    for (i = 0; i < A_lpCmd->argc; i++)
  181.    {
  182.       // Actualiser l'adresse de la commande
  183.       lpCmdAd = A_lpCmd->argv + i;
  185.       // Supprimer la memoire allouee
  186.       free(*lpCmdAd);
  187.    }
  188.    // FIN POUR
  190.    // Supprimer l'allocation pointeur
  191.    free(A_lpCmd->argv);
  193. } // fin P_FreeCommand()


Message édité par podone le 16-10-2004 à 13:19:47
n°10466
podone
POD first ONE of best game
Profil : Habitué
Posté le 16-10-2004 à 12:26:00  profilanswer
 

A noter que cette solution ne fonctionne que si la commande saisie ne déborde pas de la taille maximale autorisée.
Sinon il faut passer par la fonction fgets et effectuer une gestion des erreurs.

n°10472
linbeg
Profil : Jeune recrue
Posté le 17-10-2004 à 21:52:23  profilanswer
 

podone a écrit :

A noter que cette solution ne fonctionne que si la commande saisie ne déborde pas de la taille maximale autorisée.
Sinon il faut passer par la fonction fgets et effectuer une gestion des erreurs.


 
Un peu complexe mais efficace !!  
Merci beaucoup !!  :bounce:

n°10473
podone
POD first ONE of best game
Profil : Habitué
Posté le 17-10-2004 à 21:58:32  profilanswer
 

You're welcome !  ;)


Aller à :
Ajouter une réponse

  FORUM


  Programmation


  C - C++


  Passage de paramètre en C

 

Forum MesDiscussions.Net, Version 2007.2
(c) 2000-2007 No1Dev
Page générée en 0.261 secondes