# execvp en C/C++

Avec `execvp`, un programme peut initier des commandes système comme le lancement d’applications ou l’exécution de services système. En combinaison avec la fonction `fork()`, du code peut également être appelé après `execvp`.

## Comment fonctionne `execvp` ?

Le rôle principal de `execvp` est de donner à un programme le contrôle d’un autre, sans avoir à reconstruire tout le processus. Cela permet de basculer de manière transparente entre différentes fonctions ou d’exécuter des commandes externes avec des arguments variables. `execvp` est en quelque sorte un metteur en scène invisible qui change de décor et passe d’une intrigue à l’autre.

L’exécution dynamique du processus permet d’adapter le chemin d’accès au programme et même à ses arguments en cours d’exécution. La fonction `execvp()` est utilisée dans les appels système qui nécessitent des tâches complexes telles que l’exécution de scripts, les commandes système, le *pipelining* et les redirections. Elle contribue largement à augmenter la flexibilité des programmes C.

## La syntaxe de base de `execvp`

La syntaxe de `execvp` requiert le chemin d’accès au fichier ou le nom du programme à exécuter ainsi qu’un tableau de chaînes de caractères contenant les arguments pour ce programme.

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

- **`const char *command`** : il s’agit du chemin d’accès au fichier ou du nom du programme concerné. Il peut s’agir d’un chemin absolu ou relatif. Si un chemin relatif est utilisé, `execvp` recherche le fichier dans le PATH système.
- **`char *argv[]`** : un tableau de chaînes de caractères contenant les arguments pour le programme à exécuter. Le tableau doit se terminer par un pointeur `NULL` pour marquer la fin de la liste des arguments. La première entrée de `argv` est généralement le nom du programme lui-même, suivi des arguments.

La fonction `execvp`, tout comme d’autres fonctions de la famille `exec`, sont spécifiques aux systèmes d’exploitation **basés sur Unix**. L’instruction `#include <unistd.h>` est un fichier d’en-tête dans la programmation C. Elle contient des définitions et des déclarations de fonctions qui interagissent avec le système d’exploitation basé sur Unix et le contrôle de processus. Vous rencontrerez souvent ce fichier lors de l’apprentissage du C.

## `execvp` en pratique

Dans ce programme C, nous utilisons la fonction `execvp()` du fichier d’en-tête *unistd.h* pour lancer le programme externe `ls` avec les arguments `-l` et `/usr/bin`. Le tableau `args` représente les arguments du programme. Si la fonction `execvp()` réussit, le processus actuel est remplacé par le programme externe et les lignes suivantes sont ignorées. En cas d’erreur, un message d’erreur apparaît via `perror` et le programme renvoie le code d’état 1.

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

Avec `fork()`, on peut aussi appeler des instructions après `execvp`. La fonction `fork()` crée un nouveau processus. Ainsi, le code continue à être exécuté dans le processus parent, tandis que le nouveau processus démarre le programme externe.

```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;
}
```

Tout d’abord, nous créons un nouveau processus avec `fork()`. Grâce à la fonction `execvp()`, `ls` prend en charge le processus enfant avec ses arguments. Le processus parent attend avec `waitpid` la fin du processus enfant et affiche ensuite le message.


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/execvp/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/execvp/) for AI/LLM consumption.