# Funzione execvp() in C/C++

La funzione `execvp()` permette a un programma di eseguire comandi di sistema come l’avvio di applicazioni o l’esecuzione di servizi di sistema. In combinazione con la funzione `fork()`, è possibile eseguire del codice anche dopo `execvp()`.

## Come funziona `execvp()`?

Il compito principale di `execvp()` è quello di dare a un programma il controllo su un altro senza dover riavviare l’intero processo. In questo modo si ha la possibilità di passare facilmente da una funzione all’altra o di eseguire comandi esterni con argomenti variabili. `execvp()` è come un regista invisibile che cambia lo scenario e salta avanti e indietro tra le diverse trame.

L’esecuzione dinamica dei processi permette di modificare il percorso del programma e persino i suoi argomenti durante l’esecuzione. La funzione `execvp()` viene utilizzata nelle chiamate di sistema che richiedono compiti complessi come l’esecuzione di script, comandi di sistema, pipelining e reindirizzamenti. Contribuisce in modo significativo ad aumentare la flessibilità dei programmi di C.

## La sintassi di base di `execvp()`

La sintassi di `execvp()` richiede il percorso del file o il nome del programma da eseguire e un array di stringhe contenenti gli argomenti di questo programma.

```c
#include <unistd.h>
int execvp()(const char *command, char* argv[]);
```

- **`const char *command`**: si tratta del percorso del file o del nome del rispettivo programma, che può essere sia assoluto che relativo. Se viene utilizzato un percorso relativo, `execvp()` cerca il file nel percorso (PATH) del sistema.
- **`char *argv[]`**: questo è l’array di stringhe contenenti gli argomenti del programma da eseguire; l’array deve terminare con un puntatore `NULL` per indicare la fine dell’elenco degli argomenti. La prima voce di `argv` è solitamente il nome del programma stesso, seguito dagli argomenti.

La funzione `execvp()` e le altre della famiglia `exec` sono specifiche dei **sistemi operativi Unix**. L’istruzione `#include <unistd.h>` è un file di intestazione nella programmazione di C contenente definizioni e dichiarazioni di funzioni che interagiscono con il sistema operativo basato su Unix e con il controllo dei processi. Chi per un motivo o per l’altro si ritrova a [imparare C](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/imparare-c/), ha spesso a che fare con questo tipo di file.

Consiglio Vuoi saperne di più sul linguaggio di programmazione C? Leggi il nostro articolo al riguardo e scopri come funziona la programmazione orientata agli oggetti (OOP) in C.

## `execvp()`: un esempio pratico

Nel programma C presentato qui di seguito, utilizziamo la funzione `execvp()` del file di intestazione unistd.h per avviare il programma esterno `ls` con gli argomenti `-l` e `/usr/bin`. L’array `args` rappresenta gli argomenti del programma. Se la funzione `execvp()` viene portata a termine con successo, il processo corrente viene sostituito dal programma esterno e le righe successive vengono ignorate. In caso di errore, compare un messaggio di errore tramite `perror` e il programma restituisce il codice di stato 1.

```c
#include <unistd.h>
int main() {
    char *args[] = {"ls", "-l", "/usr/bin", NULL};
    execvp()("ls", args);
    perror("execvp()");
    return 1;
}
```

La funzione `fork()` consente di eseguire istruzioni anche dopo `execvp()` attraverso la creazione di un nuovo processo. Di conseguenza, nel processo padre, il codice continua a essere eseguito, mentre il processo figlio avvia il programma esterno.

```c
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
    char* command = "ls";
    char *args[] = {"ls", "-l", "/usr/bin", NULL};
    printf("Before calling execvp()\n");
    pid_t child_pid = fork();
    if (child_pid == -1) {
        // Error creating the process
        perror("fork");
        return 1;
    }
    if (child_pid == 0) {
        // Code executed in the child process
        // Call execvp() in the child process to execute "ls" with the specified arguments
        int status_code = execvp()(command, args);
        // This line is reached if execvp() encounters an error
        perror("execvp()");
        // Print statement after execvp()
        printf("ls -l /usr/bin has taken control of this child process. If this is printed, execvp() encountered
       an error.\n");
        // Error handling in the child process
        return 1;
    } else {
        // Code executed in the parent process
        // Wait for the completion of the child process
        waitpid(child_pid, NULL, 0);
        printf("The child process has completed its execution.\n");
    }
    return 0;
}
```

Prima di tutto occorre creare un nuovo processo utilizzando `fork()`. Attraverso la funzione `execvp()`, `ls`, unitamente ai suoi argomenti, prende il controllo del processo figlio. Il processo padre attende il completamento del processo figlio con `waitpid`, dopodiché emette il messaggio.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/funzione-execvp/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/funzione-execvp/) for AI/LLM consumption.