Parametrii liniei de comanda.

1. Parametrii liniei de comanda. Un program executabil (o comandă) poate fi lansat în execuţie de către interpretorul de comenzi al sistemului de operare. De exemplu, programul salut.exe care afişează la terminal mesajul “Buna ziua!” este o comandă fără parametrii, lansată în execuţie prin: >salut O comandă poate avea şi parametri, care apar după numele comenzii şi sunt separaţi prin spaţii libere. De exemplu programul salut.exe ar putea avea un parametru şir de caractere, care să specifice un anumit mesaj, fiind lansat în execuţie, în acest caz prin: > salut mesaj

2. Parametrii liniei de comanda Un program care copiază un fişier; acesta ar avea doi parametri, desemnând fişierele sursă şi destinaţie (şiruri de caractere ): >copiere sursa.dat dest.dat Programul poate avea acces la parametrii liniei de comandă, dacă funcţia main() prezintă argumente: void main(int argc, char *argv[]) { … } Primul argument, argc (argumentul contor) este un întreg care reprezintă numărul de parametri ai comenzii. Al doilea argument,argv (argumentul vector) este un pointer la un tablou de pointeri la şiruri de caractere, care conţin argumentele (câte un argument pe şir de caractere).

3. Parametrii liniei de comanda.

4. Parametrii liniei de comanda argv[0] conţine întotdeauna numele programului, astfel încât pentru o comandă fără parametri argc=1, iar o comandă cu 2 parametri va avea argc=3. argv[1] conţine primul parametru, argv[2] – pe cel de-al doilea, argv[argc-1] va conţine ultimul parametru, argv[argc] va fi un pointer la un şir vid (NULL). Exemplul Să se copieze la ieşire fişierele date ca parametri ai comenzii. Dacă nu avem parametri se copiază fişierul standard de intrare (stdin).

5. Exemplul 1: Copierea unui fisier. #include <stdio.h> void copy(FILE *, FILE *); main(int argc, char *argv[]) { FILE *pf; if(argc==1) copy(stdin, stdout); else while(--argc) if((pf==fopen(*++argv,”r”))==NULL) {fprintf(stderr,“Eroare deschidere %s\n”, *argv); return 1; } else

6. Exemplul 1: Copierea unui fisier. { copy(pf, stdout); fclose(pf); } return 0; } void copy(FILE *s, FILE *d) { int c; while((c=getc(s))!=EOF) putc(c, d); }

7. Functii cu numar variabil de parametri. Funcţiile C pot fi apelate cu număr variabil de parametri actuali. (de exemplu funcţiile printf() şi scanf() ). Programatorul îşi poate scrie propriile funcţii cu număr variabil de parametri, folosind macroinstrucţiunile din fişierul antet <stdarg.h>. O funcţie cu număr variabil de parametri va avea prototipul: tip nume (listă_fixă_parametri, …); Lista fixă de parametri trebuie să fie nevidă, deci numărul de parametri va fi mai mare sau egal cu numărul de parametri ficşi. Parametrii care sunt în număr variabil sunt convertiţi implicit ca tip, şi anume: • toţi întregii la int • toţi realii la double

8. Functii cu numar variabil de parametri. Fişierul antet <stdarg.h>conţine definiţii pentru tipul va_list. Argumentele variabile vor fi accesate printr-o variabilă pointer pa, declarată astfel: va_list pa; Iniţializarea pointerului de acces la argumentele variabile -pa se face folosind macroinstrucţiunea va_start() , indicând adresa ultimului parametru fix lastarg: va_start(pa, lastarg); Pentru parcurgerea listei de argumente variabile se va folosi macroinstrucţiunea va_arg(), care actualizează pointerul de acces la argumente pa, pentru a indica următorul argument int sau double, şi întoarce ca rezultat argumentul curent din lista de parametri variabili:

9. Functii cu numar variabil de parametri. vint=va_arg(pa, int); sau vreal=va_arg(pa, double); Oprirea procesului repetitiv se face folosind informaţiile despre parametrii ficşi (în vârful stivei se va afla pointerul la format). După ultimul parametru variabil extras se apelează macroinstrucţiunea: va_end(pa); Exemplul 2: Scrieţi o funcţie care afişează un număr variabil de şiruri de caractere (cel mult max).

10. Exemplul 2. #include <stdio.h> #include <stdarg.h> int printvar(int max, …); void main(void) { printvar(3,”Ion”,”Vasile”,”Mihai”); printf(“\n”); printvar(5,”marti”,”joi”,”luni”, ”vineri”,”duminica”); printf(“\n”); }

11. Exemplul 2. void printvar(int max,…) { va_list pa; int narg=0; char *siruri[10]; va_start(pa,max); while(narg < max) { siruri[narg]=va_arg(pa, char*); printf(“%s \n”, siruri[narg++]); } va_end(pa); }

12. Functii cu numar variabil de parametri. Extragerea argumentelor variabile, poate fi făcută, şi cu alte funcţii, în loc de va_arg(). În acest scop se folosesc funcţiile: vprintf(), vfprintf() şi vsprintf(). Acestea au prototipurile: int vprintf(char * format, va_list pa); • afişează, sub controlul formatului, la ieşirea standard, un număr variabil de argumente, accesate prin pointerul pa • întoarce numărul de octeţi afişaţi (rezultat negativ la eroare) int vfprintf(FILE * fis, char * format, va_list pa); • afişează, sub controlul formatului, în fişierul fis, un număr variabil de argumente, accesate prin pointerul pa • întoarce numărul de octeţi afişaţi (rezultat negativ la eroare)

13. Exemplul 3. #include <stdio.h> #include <stdarg.h> #define NUMEFIS “fis.dat” void printvar(FILE* f, char* fmt, …); int main() { FILE* f1; fmt1[]=”%s %s %s\n”; f1=fopen(NUMEFIS, “w”); printvar(f1,fmt1,”Ion”,”Vasile”,”Mihai”); fclose(f1); return 0; }

14. Functii cu numar variabil de parametri. void printvar(FILE* f, char* fmt,…) { va_list pa; va_start(pa,fmt); vfprintf(f, fmt, pa); va_end(pa); } int vsprintf(char * sir, char * format, va_list pa); • afişează, sub controlul formatului, în şirul de caractere sir, un număr variabil de argumente, accesate prin pointerul pa

15. Exemplul 4. Exemplul 4: Scrieţi o funcţie cu număr variabil de parametri, care simulează funcţia printf(), acceptând parametri variabili de tip int, double sau şir de caractere. #include <stdio.h> #include <stdarg.h> void printvar(char* fmt,…) { va_list pa; char *p, *psir; int i; double d; va_start(pa,fmt);

16. Exemplul 4. for (p=fmt; *p; p++) { if(*p!=‘%’){ putchar(*p); continue; } switch(*++p) { case ‘d’: i=va_arg(pa, int); printf(“%d”,i); break; case ‘f’: d=va_arg(pa, double); printf(“%lf”,d); break;

17. Exemplul 4. case ‘s’: for (psir=va_arg(pa,char*); *psir;psir++) putchar(*psir); break; default: putchar(*p); break; } } va_end(pa); }