# Execvp in C/C++

Mit `execvp` ist ein Programm in der Lage, Systemkommandos wie das Starten von Anwendungen oder das Ausführen von Systemdiensten zu initiieren. In Kombination mit der `fork()`-Funktion kann auch Code nach `execvp` aufgerufen werden.

## Wie funktioniert `execvp`?

Die Hauptaufgabe von `execvp` ist es, einem Programm die Kontrolle über ein anderes zu übergeben, ohne den gesamten Prozess neu aufzusetzen. Dies ermöglicht das nahtlose Umschalten zwischen verschiedenen Funktionen oder das Ausführen externer Befehle mit variablen Argumenten. `execvp` ist wie ein unsichtbarer Regisseur, der die Kulissen wechselt und zwischen verschiedenen Handlungssträngen hin- und herspringt.

Durch die dynamische Prozessausführung können Sie den Pfad zum Programm und sogar dessen Argumente während der Laufzeit anpassen. Die `execvp()`-Funktion findet Anwendung in Systemaufrufen, die komplexe Aufgaben wie Skriptausführung, Systemkommandos, Pipelining und Redirektionen erfordern. Sie trägt wesentlich dazu bei, die Flexibilität von C-Programmen zu erhöhen.

## Die grundlegende Syntax von `execvp`

Die Syntax von `execvp` erfordert den Dateipfad oder Namen zum auszuführenden Programm sowie ein Array von Zeichenketten, das die Argumente für dieses Programm enthält.

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

- **`const char *command`**: Dies ist der Dateipfad oder der Name des jeweiligen Programms. Es kann sowohl ein absoluter als auch ein relativer Pfad sein. Bei Verwendung eines relativen Pfads sucht `execvp` nach der Datei im System-PATH.
- **`char *argv[]`**: Ein Array von Zeichenketten, das die Argumente für das auszuführende Programm enthält; das Array muss mit einem `NULL`-Zeiger enden, um das Ende der Argumentliste zu kennzeichnen. Der erste Eintrag in `argv` ist üblicherweise der Name des Programms selbst, gefolgt von den Argumenten.

Die `execvp` und andere Funktionen aus der `exec`-Familie sind spezifisch für **Unix-basierte Betriebssysteme**. Die `#include <unistd.h>`-Anweisung ist eine Header-Datei in der C-Programmierung. Sie enthält Definitionen und Deklarationen von Funktionen, die mit dem Unix-basierten Betriebssystem und der Prozesskontrolle interagieren. Sie werden der Datei beim C-Lernen häufig begegnen.

## Der praktische Einsatz von `execvp`

Im vorliegenden C-Programm nutzen wir die `execvp()`-Funktion aus der unistd.h-Header-Datei, um das externe Programm `ls` mit den Argumenten `-l` und `/usr/bin` zu starten. Das Array `args` steht für die Argumente des Programms. Wenn die `execvp()`-Funktion erfolgreich ist, wird der aktuelle Prozess durch das externe Programm ersetzt, und die nachfolgenden Zeilen werden ignoriert. Im Fehlerfall erscheint eine Fehlermeldung über `perror`, und das Programm gibt den Statuscode 1 zurück.

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

Mit `fork()` können Sie Anweisungen auch nach `execvp` aufrufen. Die `fork()`-Funktion schafft einen neuen Prozess. Dadurch wird im Elternprozess weiterhin Code ausgeführt, während der neue Prozess das externe Programm startet.

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

Zuerst erstellen wir einen neuen Prozess mittels `fork()`. Durch die `execvp()`-Funktion übernimmt `ls` mit seinen Argumenten den Child Process. Der Elternprozess wartet mit `waitpid` auf den Abschluss des Kindprozesses und gibt danach die Meldung aus.


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/execvp/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/execvp/) for AI/LLM consumption.