Funzione Execv nella lingua C

Esistono diversi modi e funzioni per avviare i processi da un programma. Ognuno di essi offre diverse soluzioni al programmatore a seconda delle esigenze del caso particolare.

IL Execxx () La famiglia è un insieme di funzioni di sistema definite nel "UNISTD.H ”intestazione per eseguire un processo all'interno di un programma. Questa famiglia di funzioni ci consente di inviare gli argomenti di input all'eseguibile che lo chiama motivo per cui è una risorsa molto utile per l'interazione tra i processi.

In questo Suggerimento Linux Articolo, imparerai tutto sul Execv () funzione nella lingua C. Esamineremo la sua sintassi, la descrizione teorica di come funziona, gli argomenti di input e output e il tipo di dati che ciascuno di essi elabora. Imparerai anche come creare e utilizzare le matrici di stringhe e puntatori che fanno parte degli argomenti di input di questa famiglia di funzioni e sono passati al processo di chiamata.

Quindi, applichiamo ciò che abbiamo appreso in un esempio pratico che mostra la corretta implementazione e chiamata del Execv () funzione.

Sintassi della funzione Execv () in lingua C

int execv (const char *percorso, char *const argv []);

Descrizione della funzione Execv () nella lingua C

IL Execv () La funzione esegue un processo da un altro processo o programma. Questa funzione esegue il file o eseguibile specificato *sentiero discussione. Questa voce dovrebbe contenere il percorso assoluto o relativo del file eseguibile in formato stringa.

IL *argv [] L'argomento è un array di puntatori alle stringhe in cui ogni stringa è un argomento di input che viene passato al processo da eseguire. Il primo puntatore dell'array dovrebbe sempre indicare una stringa che contiene il nome del file eseguibile e l'ultimo puntatore dovrebbe essere sempre nullo. Quando Execv () è chiamato, il processo da cui è stato chiamato è terminato, riscritto e sostituito dal nuovo processo nella parte allocata della memoria e con lo stesso ID.

Se la funzione viene eseguita correttamente, non restituisce. Se ritorna, è perché si verifica un errore. Gli errori che questa funzione possono generare sono variati, che vanno dal percorso del file eseguibile inesistente alle autorizzazioni negate.

L'errore può essere identificato recuperando il suo valore da errno variabile globale. Nella parte successiva, vedremo una sezione speciale che spiega gli errori più comuni di questa funzione e la loro identificazione.

La famiglia di Execxx () Le funzioni sono definite in "UNISTD.H ”intestazione. Per usarli, dobbiamo includerli nel nostro ".File C "come segue:

#includere

Come eseguire un processo da un programma utilizzando la funzione Execv () in C lingua

In questo esempio, spiegheremo come usare il Execv () funzione per eseguire un processo e passare gli argomenti di input da un programma a un altro.

Per fare questo, creiamo due codici molto semplici. Uno è il processo principale che chiama la funzione Execv () per eseguire il processo figlio. Quando il Execv () La funzione avvia il processo figlio, lo passa con tre argomenti di input sotto forma di una stringa che il processo figlio recupera e viene visualizzato sulla shell.

Processo figlio

Il processo figlio è un semplice pezzo di codice che stampa il "Sono il processo di bambino " messaggio, recupera gli argomenti di input inviati dal processo genitore e li visualizza sulla shell. Ecco il codice per il processo figlio:

#includere
#includere
#includere
int main (int argc, char *argv [])

printf ("I Am The Child Process");
printf ("argomento 1: %s \ n", argv [1]);
printf ("argomento 2: %s \ n", argv [2]);
printf ("argomento 3: %s \ n", argv [3]);

Compiliamo questo codice e salviamo la sua produzione in "documenti" con il nome "figlio" con ".Estensione bin ”come mostrato nel seguente:

~ $ GCC documenti/bambino.C -o documenti/bambino.bidone

In questo modo, salviamo il file eseguibile del bambino in "documenti". Il percorso di questo eseguibile è l'argomento di input, sentiero, Quando si chiama Execv () Nel processo genitore.

Processo genitore

Il processo genitore è quello da cui chiamiamo il Execv () funzione per eseguire il processo figlio. In questo codice, definiamo un array di puntatori alle stringhe che rappresentano gli argomenti di input al processo che il Execv () La funzione si apre.

Puoi vedere come creare correttamente una serie di puntatori alle stringhe nella seguente illustrazione. In questo caso, è composto da 5 puntatori e viene chiamato arg_ptr [].

char *arg_ptr [5];

Una volta definita l'array di puntatori, a ciascun puntatore deve essere assegnata una stringa che contiene l'argomento di input che inviamo al processo figlio.

Puoi vedere come assegnare ciascun puntatore con l'argomento corrispondente in formato stringa nella seguente illustrazione:

arg_ptr [0] = "figlio.C";
arg_ptr [1] = "\ nhello da";
arg_ptr [2] = "processo 2";
arg_ptr [3] = null;

Un altro modo per assegnare le stringhe all'array di puntatore è quello di racchiudere le corde in parentesi graffe e separarle con virgole:

arg_ptr [] = "figlio.c, "\ nhello da", "processo 2", null;

Dopo aver definito l'array di puntatori per ogni argomento, il passo successivo è chiamare il Execv () funzione, passando la stringa che contiene il percorso assoluto o relativo del file eseguibile come primo argomento e l'array di stringhe arg_ptr []Come il secondo argomento.

Puoi vedere il "principale" completo del processo genitore nella seguente illustrazione:

#includere
#includere
#includere
#includere
#includere
int main ()
printf ("\ n \ ni am il processo principale \ n");
char *arg_ptr [5];
arg_ptr [0] = "figlio.C";
arg_ptr [1] = "\ nhello da";
arg_ptr [2] = "processo 2";
arg_ptr [3] = null;
Execv ("/Home/LinuxHint/Child.bin ", arg_ptr);

Compiliamo questo codice che specifica il percorso del ".C ”file e il nome dell'out.

~ $ GCC documenti/genitore.pattern c -o

Quindi, eseguiamo l'output.

~ $ ./ modello

Il processo genitore visualizza il "Sono il processo genitore" messaggio, crea l'array stringa assegnando una stringa per ogni argomento di input che viene passato al processo successivo e chiama il Execv () funzione. Se la Execv () La funzione esegue correttamente, il bambino.Il bidone eseguibile sostituisce il processo genitore e assume il suo ID e la memoria allocata, quindi questa azione non può essere annullata.

Il processo figlio visualizza il file "Sono il processo di bambino" messaggio e recupera ciascuno degli argomenti di input che vengono passati dal processo genitore da visualizzare sulla console di comando.

Come riconoscere possibili errori quando si utilizza la funzione Execv ()

IL Execv () La funzione non restituisce se viene eseguita correttamente. Se ritorna al codice che lo chiamava, si è verificato un errore. Gli errori che possono essere generati da questa funzione sono molteplici poiché l'operazione dipende da due diversi processi, percorsi di file, autorizzazioni di accesso e così via.

Il modo per identificare l'errore è attraverso errno variabile globale. Questa variabile è un numero intero ed è definita nel "errno.H ”intestazione. Ogni volta che si verifica un errore, viene memorizzato un valore numerico che rappresenta un particolare errore.

Successivamente, esaminiamo le definizioni e il valore rappresentativo dei possibili errori che possono verificarsi quando si utilizza questa funzione:

Generiamo un errore nella paterna.Codice C, indicando un percorso file inesistente al Execv () funzione. Quindi, utilizzare la funzione printf per visualizzare il codice di errore ottenuto da errno variabile nella console:

#includere
#includere
#includere
#includere
#includere
int main ()
printf ("\ n \ ni am il processo principale \ n");
char *arg_ptr [5];
arg_ptr [0] = "figlio.C";
arg_ptr [1] = "\ nhello da";
arg_ptr [2] = "processo 2";
arg_ptr [3] = null;
Execv ("/home/linuxhint/non esistente.bin ", arg_ptr);
printf ("Errore: %i \ n", errno);

Come possiamo vedere nella figura seguente, la funzione Execv () non è stataNessun file o directory con questo nome" errore.

Conclusione

In questo Suggerimento Linux Articolo, abbiamo spiegato come usare il Execv () funzione nel linguaggio C per avviare un processo da un altro processo. Abbiamo spiegato il funzionamento teorico di Execv () e ha mostrato come dichiarare gli argomenti di input.

Abbiamo quindi implementato ciò che abbiamo appreso in un esempio, mostrandoti come creare il programma genitore e il processo figlio passando gli argomenti da uno all'altro. Inoltre, abbiamo visto una sezione speciale in cui mostriamo gli errori più comuni di questa funzione e come identificarli usando la variabile Errno.

Speriamo che questo articolo sia utile per te. Per ulteriori articoli sulla lingua C e sui suggerimenti Linux, utilizzare il motore di ricerca sul nostro sito Web.