# Hoe execvp() te gebruiken in C en C++

Met `execvp` kan een programma systeemopdrachten starten, zoals het starten van applicaties of het uitvoeren van systeemservices. In combinatie met de functie `fork()` kan code ook worden aangeroepen na `execvp`.

## Hoe werkt `execvp`?

Het belangrijkste doel van `execvp` is om het mogelijk te maken dat het ene programma het andere programma bestuurt zonder het hele proces opnieuw te starten. Dit maakt het mogelijk om naadloos te schakelen tussen verschillende functies of om externe commando’s met variabele argumenten uit te voeren. `execvp` fungeert als een onzichtbare regisseur, die het decor verandert en heen en weer springt tussen verschillende verhaallijnen.

Met dynamische procesuitvoering kunt u het programmapad en de bijbehorende argumenten tijdens de uitvoering aanpassen. De functie `execvp()` wordt gebruikt in systeemaanroepen die complexe taken vereisen, zoals scriptuitvoering, systeemopdrachten, pipelining en omleidingen. Dit vergroot de flexibiliteit van C-programma’s aanzienlijk.

## Wat is de syntaxis van `execvp`?

De functie `execvp` heeft twee parameters nodig: het bestandspad of de naam van het programma dat u wilt uitvoeren en een reeks strings met de argumenten voor dat programma.

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

- **`const char *command`**: Dit is het bestandspad of de naam van het programma dat u wilt uitvoeren. Dit kan een absoluut pad of een relatief pad zijn. Als een relatief pad wordt gebruikt, `execvp` zoekt het programma naar het bestand in de systeem-PATH.
- **`char *argv[]`**: Een reeks strings met de argumenten voor het uit te voeren programma. De reeks moet eindigen met een `NULL` pointer om het einde van de argumentenlijst aan te geven. De eerste invoer in `argv` is meestal de naam van het programma zelf, gevolgd door de argumenten.

De `execvp` -functie en andere functies uit de `exec` zijn specifiek voor **op Unix gebaseerde besturingssystemen**. De `#include <unistd.h>` instructie is een headerbestand in C-programmering dat definities en declaraties bevat van functies voor interactie met een op Unix gebaseerd besturingssysteem en procescontrole. Je zult dit bestand vaak tegenkomen wanneer je leert om code te schrijven in C.

## Voorbeeld van hoe je `execvp` kunt gebruiken

In het onderstaande voorbeeld gebruiken we de functie `execvp()` uit het headerbestand unistd.h om het externe programma `ls` te starten met de argumenten `-l` en `/usr/bin`. De array `args` staat voor de argumenten van het programma. Als de functie `execvp()` succesvol is, wordt het huidige proces vervangen door het externe programma en worden de volgende regels genegeerd. In geval van een fout wordt er via `perror` een foutmelding weergegeven en geeft het programma de statuscode 1 terug.

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

Met `fork()` kunt u een nieuw proces aanmaken. In dit onderliggende proces kunt u met `execvp` een ander programma uitvoeren. Hierdoor kan het bovenliggende proces zijn eigen code blijven uitvoeren, terwijl het nieuwe proces het externe programma start.

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

In het bovenstaande voorbeeld hebben we een nieuw proces gemaakt met behulp van `fork()`. Met behulp van de functie `execvp()` neemt `ls` het kindproces met zijn argumenten over. Met `waitpid` wacht het ouderproces tot het kindproces is voltooid en geeft vervolgens het bericht weer.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/execvp/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/execvp/) for AI/LLM consumption.