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
 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).
 Parametrii liniei de comanda.
argv

argv[0]
copiere

argv[1]
dest.dat

argv[2]
sursa.dat

argv[argc]
\0
 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).
 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
 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);
}
 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
 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:
 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).
 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”);
}
 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);
}
 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)
 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;
}
 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
 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);
 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;
 Exemplul 4.
case ‘s’:
for (psir=va_arg(pa,char*);
*psir;psir++)
putchar(*psir);
break;
default:
putchar(*p);
break;
}
}
va_end(pa);
}