În acest articol, voi vorbi despre familia de funcții exec și vă voi arăta cum să utilizați fiecare dintre aceste funcții familiale exec în C. Deci, să începem.
Funcțiile sistemului C din familia Exec:
Familiile de funcții exec sunt definite în antet unistd.h . Deci, trebuie să utilizați acest antet pe programul C unde doriți să utilizați aceste funcții.
Funcțiile exec disponibile împreună cu parametrii lor de funcție sunt date mai jos:
- int execl (const char * path, const char * arg, ..., NULL);
- int execlp (const char * file, const char * arg, ..., NULL);
- int execv (const char * path, char * const argv []);
- int execvp (const char * file, char * const argv []);
- int execle (const char * path, const char * arg, ..., NULL, char * const envp []);
- int execve (const char * file, char * const argv [], char * const envp []);
Să vedem ce fac fiecare dintre aceste funcții și cum să le folosim.
execl () Funcția sistemului:
Funcția de sistem execl () ia calea fișierului binar executabil (adică / bin / ls ) ca primul și al doilea argument. Apoi, argumentele (adică -lh , /Acasă ) pe care doriți să îl treceți la executabil urmat de NUL . Apoi funcția de sistem execl () execută comanda și imprimă ieșirea. Dacă apare orice eroare, atunci execl () returnează -1. În caz contrar, nu returnează nimic.
Sintaxă:
intexecl(const char *cale, const char *furios,...,NUL);Un exemplu al funcției de sistem execl () este dat mai jos:
#include
intprincipal(nul) {
char *binaryPath= „/ bin / ls”;
char *arg1= „-lh”;
char *arg2= '/Acasă';
execl(binaryPath,binaryPath,arg1,arg2,NUL);
întoarcere 0;
}
Am condus ls -lh / acasă comandă folosind funcția de sistem execl (). După cum puteți vedea, este afișat rezultatul corect.
execlp () Funcția sistemului:
execl () nu folosește CALE variabilă de mediu. Deci, calea completă a fișierului executabil este necesară pentru al rula cu execl (). execlp () utilizează variabila de mediu PATH. Deci, dacă un fișier executabil sau o comandă este disponibil în PATH, atunci comanda sau numele fișierului este suficient pentru al rula, calea completă nu este necesară.
Sintaxă:
intexeclp(const char *fişier, const char *furios,...,NUL);Putem rescrie exemplul execl () folosind funcția de sistem execlp () după cum urmează:
#includeintprincipal(nul) {
char *numele programului= „eu”;
char *arg1= „-lh”;
char *arg2= '/Acasă';
execlp(numele programului,numele programului,arg1,arg2,NUL);
întoarcere 0;
}
Am trecut doar numele comenzii eu sunt , nu calea completă / bin / ls . După cum puteți vedea, am obținut același rezultat ca înainte.
execv () Funcția sistemului:
În funcția execl (), parametrii fișierului executabil sunt transferați funcției ca argumente diferite. Cu execv (), puteți trece toți parametrii într-o matrice terminată NULL argv . Primul element al matricei ar trebui să fie calea fișierului executabil. În caz contrar, funcția execv () funcționează la fel ca funcția execl ().
Sintaxă:
intexecv(const char *cale, char *constargv[]);Putem rescrie exemplul execl () după cum urmează:
#includeintprincipal(nul) {
char *binaryPath= „/ bin / ls”;
char *argumente[] = {binaryPath, „-lh”, '/Acasă',NUL};
execv(binaryPath,argumente);
întoarcere 0;
}
După cum puteți vedea, obțin rezultatul corect.
execvp () Funcția sistemului:
Funcționează la fel ca funcția de sistem execv (). Dar se utilizează variabila de mediu PATH. Deci, calea completă a fișierului executabil nu este necesară la fel ca în execlp ().
Sintaxă:
intexecvp(const char *fişier, char *constargv[]);Putem rescrie exemplul execv () după cum urmează:
#includeintprincipal(nul) {
char *numele programului= „eu”;
char *argumente[] = {numele programului, „-lh”, '/Acasă',NUL};
execvp(numele programului,argumente);
întoarcere 0;
}
După cum puteți vedea, este afișat rezultatul corect.
execle () Funcția sistemului:
Funcționează la fel ca execl (), dar puteți furniza propriile variabile de mediu împreună cu acesta. Variabilele de mediu sunt transmise ca o matrice invp . Ultimul element al invp matricea ar trebui să fie NULL. Toate celelalte elemente conțin perechile cheie-valoare ca șir.
Sintaxă:
intexecle(const char *cale, const char *furios,...,NUL, char * constinvp[] );Un exemplu al funcției de sistem execle () este dat mai jos:
#includeintprincipal(nul) {
char *binaryPath= „/ bin / bash”;
char *arg1= „-c”;
char *arg2= 'aruncat 'Vizitați $ HOSTNAME:$ PORT din browserul dvs.'';
char *constenv[] = {„HOSTNAME = www.linuxhint.com”, „PORT = 8080”,NUL};
execle(binaryPath,binaryPath,arg1,arg2,NUL,env);
întoarcere 0;
}
Am trecut două variabile de mediu NOMUL DE GĂȘTARE și PORT la funcția execle (). După cum puteți vedea, le pot accesa din executabil / bin / bash .
execve () Funcția sistemului:
La fel ca execle () puteți furniza propriile variabile de mediu împreună cu execve (). Puteți, de asemenea, să transmiteți argumente la fel de matrice ca și în execv ().
Sintaxă:
intexecve(const char *fişier, char *constargv[], char *constinvp[]);Exemplul execle () poate fi rescris după cum urmează:
#includeintprincipal(nul) {
char *binaryPath= „/ bin / bash”;
char *constargumente[] = {binaryPath, „-c”, 'aruncat 'Vizitați $ HOSTNAME:$ PORT
din browserul dvs.'',NUL};
char *constenv[] = {„HOSTNAME = www.linuxhint.com”, „PORT = 8080”,NUL};
execve(binaryPath,argumente,env);
întoarcere 0;
}
După cum puteți vedea, obținem aceeași ieșire ca în exemplul execle ().
Deci, așa utilizați familia de funcții exec în C pentru programarea sistemului în Linux. Vă mulțumim că ați citit acest articol.