ProbleM: int argc,char *argv[]

Kezdőlap Fórumok Programozás ProbleM: int argc,char *argv[]

10 bejegyzés megtekintése - 1-10 / 11
  • Szerző
    Bejegyzés
  • #1999024
    dexter11
    Felhasználó

      Sziasztok!

      Egy progimban kéne a következõ: bekér egy sztringet,melyben lehetnek space karakterek,tehát olyan,mint egy shell parancs.flexibilis kell hogy legyen,tehát nem feltételezhetem,hogy 1 parancs és 3 argumentumot ad mindig a user,
      Magyarán egy main(int argc,char  *argv[]) tipusú függvényt szeretnék megvalósitani,de nem igazán vagyok otthon a sztringeknél..
      – próbáltam scanf,fgets,sscanf,mindennel,nyakatekert módszerekkel,de egyszerûen semmi sem jó!
      elvileg ilyet kéne,nem? :

      Code:
      argc=scanf(„%s %s %s %s %sn”,argv[0],argv[1],argv[2],argv[3],argv[4])

      ha maximálom az argumentumok számát 4-re(+1  a parancs)
      de ez nem megy,mert ha csak egy sztringet adok meg és utána enter,akkor még bekéri a következõ 4-t is!!!

      2mo:

      Code:
      char *st=(char*)NULL;
      fgets(stdin,256,st);

      majd pedig ezután az st karakterláncból kiválogatom a részláncokat strchr,meg substr,meg hasonlókkal,ez menne is,de ez elég kókány megoldás,van vmi jobb ötletetek?
      Köszi!
      [align=right][snapback]113131[/snapback][/align]

      Tudtommal az argc a megadott paraméterek száma, az argv meg a megadott paraméterek tömbje. Tehát ha a programot így indítod :

      Code:
      program paraméter1 paraméter2 …

      akkor az argv[1]=paraméter1, argv[2]=paraméter2 stb és argc=2. Nem kell sem scanf sem fgets.

      #1999025
      Fawaid
      Felhasználó

        Dexter azt én is tudom h a MAIN függvény paraméterei mit jelentenek,és a programhivásnál bekerülnek a változókba az argumentumok.
        De képzelj el egy fuggv(int argc,char *argv[]); prototipust,mely azt csinálja,hogy már az elinditott programomban(!) bekér egy parancssori utasitást.Ezt hogyan tegyem be a függvény paramétereibe,melyet majd be-kimenö nek választok?
        Valaki?

        #1999026
        Fawaid
        Felhasználó

          Egyébként:

          Code:
          program param1 param2 param3

          akkor argv[0]=program ,argv[1]=param1 stb,és argc=4..
          De ez most nem lényeg.Azért köszi…. B)

          #1999027
          Leslieman
          Felhasználó

            Hát Fawaid…. bocsi, de

            #1999028
            kelemengabor
            Felhasználó

              A c++-ban van ilyen, nézz utána!
              [align=right][snapback]113439[/snapback][/align]

              C-ben is. Lásd: nagykönyv (K&R) vagy man stdarg.

              #1999029
              dexter11
              Felhasználó

                Csatlakozom Lesliemanhez én sem értem mit akarsz. Ha elsõre jobban leírtad volna arra válaszolok – ha tudok.

                #1999030
                dexter11
                Felhasználó

                  Dexter azt én is tudom h a MAIN függvény paraméterei mit jelentenek,és a programhivásnál bekerülnek a változókba az argumentumok.
                  De képzelj el egy fuggv(int argc,char *argv[]); prototipust,mely azt csinálja,hogy már az elinditott programomban(!) bekér egy parancssori utasitást.Ezt hogyan tegyem be a függvény paramétereibe,melyet majd be-kimenö nek választok?
                  Valaki?
                  [align=right][snapback]113403[/snapback][/align]

                  Ez most valami rekurzív függvény akar lenni? Tulajdonképpen mért nem írod le, hogy pontosan mit akarsz csinálni?

                  #1999031
                  kelemengabor
                  Felhasználó

                    Ez most valami rekurzív függvény akar lenni? Tulajdonképpen mért nem írod le, hogy pontosan mit akarsz csinálni?
                    [align=right][snapback]113587[/snapback][/align]

                    Egy progimban kéne a következõ: bekér egy sztringet,melyben lehetnek space karakterek,tehát olyan,mint egy shell parancs.

                    Elég egyértelmû szerintem: egy olyan fv-t, ami bekér n db sztringet, és valahogy visszaadja a db számot.

                    #1999032
                    Fawaid
                    Felhasználó

                      program.cpp v program.c

                      #./program
                      ezittapromptom#>hello bello linuxforum en vagyok Fawaid
                      ezittapromptom#>hihih
                      ezittapromptom#>exit
                      #

                      Igy nézne ki a programom.

                      Tehát: bekérek egy parancsot.Ez lehet nulla argumentumú(hihih v.exit) vagy pl 5 argumentumú (a ‘hello’ parancs).
                      Csinálok egy int argc-t. ebben lenne az a szám hogy hány argumentumot adott meg a user +1 a parancs miatt.
                      Aztán lenne egy pointerekbõl álló tömböm char *argv[5] . (Azt mondom,maximalizálom az argumentumok számát 5-re..)
                      Kérdés:TI hogyan oldanátok meg azt,hogy :
                      ezittapromptom#>hello bello linuxforum en vagyok Fawaid esetben argv[0]=”hello”
                      argv[1]=”bello” stb,argc=6?
                      Azaz: teszem azt ezt a folyamatot egy függvény oldja meg.

                      fuggv(int argc,char *argv[]); a prototipus

                      Magyarán egy karaktersorozatból ki szeretném válogatni az egybetartozókat(azaz,amiket 1vtöbb space választ el)és ezek számát.

                      Nem kell nekem még stdarg,tudom ott vannak a változó paraméterü függvényekhez való cuccok,már használtam is ,majd ha megy maximált hosszu argumentumra,utána lehet böviteni.(First make it work.Then make it better.Then make it faster.)

                      Az én gondolkodásom:
                      char *st=(char*)NULL;
                      fgets(st,256,stdin);
                      majd pedig karakterenként végigmegyek az st tömbön,és nézegetem h space-e,ha igen,az elõtte lévõ dolgot másolom az argv tömbbe..
                      Tehát meg tudom oldani,csak az a kérdésem,hogy van-e valamelyikõtöknek egyszerübb,frappánsabb megoldása?
                      Köszi

                      #1999033
                      begyu
                      Felhasználó

                        Hi

                        A gcc infoban talalsz ilyet:

                        Code:
                            #include
                           
                            void va_start(va_list ap, LAST_REQUIRED_ARG);
                            TYPE va_arg(va_list ap, TYPE);
                            void va_end(va_list ap);

                        Description
                        ———–

                        Used to write functions taking a variable number of arguments.  Note
                        that these are actually macros, and not functions.  You must prototype
                        the function with `…’ in its argument list.  Then, you do the
                        following:

                          *  Create a variable of type `va_list’.

                          *  Initialize it by calling `va_start’ with it and the name of the
                            last required (i.e. non-variable) argument.

                          *  Retrieve the arguments by calling `va_arg’ with the `va_list’
                            variable and the type of the argument.  As another alternative,
                            you can pass the `va_list’ to another function, which may then use
                            `va_arg’ to get at the arguments.  `vprintf’ is an example of this.

                          *  Call `va_end’ to destroy the `va_list’.

                        Be aware that your function must have some way to determine the number
                        and types of the arguments.  Usually this comes from one of the required
                        arguments.  Some popular ways are to pass a count, or to pass some
                        special value (like `NULL’) at the end.

                        Also, the variable arguments will be promoted according to standard C
                        promotion rules.  Arguments of type `char’ and `short’ will be promoted
                        to `int’, and you should retrieve them as such.  Those of type `float’
                        will be promoted to `double’.

                        Return Value
                        ————

                        `va_arg’ returns the argument it fetched, the other macros return
                        nothing.

                        Portability
                        ———–

                        ANSI/ISO C   C89; C99
                        POSIX        1003.2-1992; 1003.1-2001

                        Example
                        ——-

                            int find_the_sum(int count, …)
                            {
                              va_list ap;
                              int i;
                              int total = 0;
                           
                              va_start(ap, count);
                              for (i = 0; i < count; i++)           total += va_arg(ap, int);       va_end(ap);       return total;     }         int other_function(void)     {       return find_the_sum(6, 1, 2, 3, 4, 5, 6);     }

                        Ezzel ugy lehet parameterezni egy fuggvenyt, mint a main()-t.

                      10 bejegyzés megtekintése - 1-10 / 11
                      • Be kell jelentkezni a hozzászóláshoz.