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

Met execvp kan een programma sys­teem­op­drach­ten starten, zoals het starten van ap­pli­ca­ties of het uitvoeren van sys­teem­ser­vi­ces. In com­bi­na­tie met de functie fork() kan code ook worden aan­ge­roe­pen na execvp.

Hoe werkt execvp?

Het be­lang­rijk­ste 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 ver­schil­len­de functies of om externe commando’s met variabele ar­gu­men­ten uit te voeren. execvp fungeert als een on­zicht­ba­re regisseur, die het decor verandert en heen en weer springt tussen ver­schil­len­de ver­haal­lij­nen.

Met dy­na­mi­sche pro­ces­uit­voe­ring kunt u het pro­gram­ma­pad en de bij­be­ho­ren­de ar­gu­men­ten tijdens de uit­voe­ring aanpassen. De functie execvp() wordt gebruikt in sys­teem­aan­roe­pen die complexe taken vereisen, zoals scriptuit­voe­ring, sys­teem­op­drach­ten, pi­pe­li­ning en om­lei­din­gen. Dit vergroot de flexi­bi­li­teit van C-programma’s aan­zien­lijk.

Wat is de syntaxis van execvp?

De functie execvp heeft twee pa­ra­me­ters nodig: het be­stands­pad of de naam van het programma dat u wilt uitvoeren en een reeks strings met de ar­gu­men­ten voor dat programma.

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

• const char *command: Dit is het be­stands­pad 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 ar­gu­men­ten voor het uit te voeren programma. De reeks moet eindigen met een NULL pointer om het einde van de ar­gu­men­ten­lijst aan te geven. De eerste invoer in argv is meestal de naam van het programma zelf, gevolgd door de ar­gu­men­ten.

De execvp -functie en andere functies uit de exec zijn specifiek voor op Unix ge­ba­seer­de be­stu­rings­sys­te­men. De #include <unistd.h> in­struc­tie is een he­a­der­be­stand in C-pro­gram­me­ring dat de­fi­ni­ties en de­cla­ra­ties bevat van functies voor in­ter­ac­tie met een op Unix gebaseerd be­stu­rings­sys­teem en pro­ce­s­con­tro­le. Je zult dit bestand vaak te­gen­ko­men wanneer je leert om code te schrijven in C.

Voorbeeld van hoe je execvp kunt gebruiken

In het on­der­staan­de voorbeeld gebruiken we de functie execvp() uit het he­a­der­be­stand unistd.h om het externe programma ls te starten met de ar­gu­men­ten -l en /usr/bin. De array args staat voor de ar­gu­men­ten 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 fout­mel­ding weer­ge­ge­ven en geeft het programma de sta­tus­co­de 1 terug.

#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 on­der­lig­gen­de proces kunt u met execvp een ander programma uitvoeren. Hierdoor kan het bo­ven­lig­gen­de proces zijn eigen code blijven uitvoeren, terwijl het nieuwe proces het externe programma start.

#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 bo­ven­staan­de voorbeeld hebben we een nieuw proces gemaakt met behulp van fork(). Met behulp van de functie execvp() neemt ls het kind­pro­ces met zijn ar­gu­men­ten over. Met waitpid wacht het ou­der­pro­ces tot het kind­pro­ces is voltooid en geeft ver­vol­gens het bericht weer.