Hur man använder execvp() i C och C++

Med execvp kan ett program initiera system­kom­man­don, såsom att starta ap­pli­ka­tio­ner eller köra system­tjäns­ter. När det kom­bi­ne­ras med funk­tio­nen fork() kan kod också anropas efter execvp.

Hur fungerar execvp?

Hu­vud­syf­tet med execvp är att ett program ska kunna styra ett annat utan att hela processen behöver startas om. Detta möjliggör smidig växling mellan olika funk­tio­ner eller körning av externa kommandon med variabla argument. execvp fungerar som en osynlig regissör som byter sce­no­gra­fi och hoppar fram och tillbaka mellan olika be­rät­tel­ser.

Dynamisk pro­cesskör­ning gör det möjligt att justera pro­gram­vä­gen och dess argument under körning. Funk­tio­nen execvp() används i sys­te­man­rop som kräver komplexa uppgifter såsom skript­kör­ning, system­kom­man­don, pi­peli­ning och omdi­ri­ge­ring­ar. Den för­bätt­rar avsevärt flex­i­bi­li­te­ten hos C-program.

Vad är syntaxen för execvp?

Funk­tio­nen execvp behöver två pa­ra­met­rar: filvägen eller namnet på det program du vill köra och en sträng­ma­tris med ar­gu­men­ten för det pro­gram­met.

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

• const char *command: Detta är filvägen eller namnet på det program du vill köra. Det kan vara en absolut eller relativ sökväg. Om en relativ sökväg används söker execvp efter filen i systemets PATH.
• char *argv[]: En sträng­ma­tris som in­ne­hål­ler ar­gu­men­ten för pro­gram­met som ska köras. Matrisen måste avslutas med en NULL pekare för att ange slutet på ar­gu­ment­lis­tan. Den första posten i argv är van­ligt­vis namnet på själva pro­gram­met, följt av ar­gu­men­ten.

Funk­tio­nen execvp och andra funk­tio­ner från familjen exec är specifika för Unix-baserade ope­ra­tiv­sy­stem. Uttrycket #include <unistd.h> är en huvudfil i C-pro­gram­me­ring som in­ne­hål­ler de­fi­ni­tio­ner och de­kla­ra­tio­ner av funk­tio­ner för in­ter­ak­tion med ett Unix-baserat ope­ra­tiv­sy­stem och pro­cess­kon­troll. Du kommer att stöta på den här filen ofta när du lär dig att skriva kod i C.

Exempel på hur man använder execvp

I exemplet nedan använder vi funk­tio­nen execvp() från hu­vud­fi­len unistd.h för att starta det externa pro­gram­met ls med ar­gu­men­ten -l och /usr/bin. Arrayen args står för pro­gram­mets argument. Om funk­tio­nen execvp() lyckas kommer den aktuella processen att ersättas av det externa pro­gram­met och de ef­ter­föl­jan­de raderna ignoreras. Om ett fel uppstår visas ett fel­med­de­lan­de via perror och pro­gram­met re­tur­ne­rar sta­tus­ko­den 1.

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

Med fork() kan du skapa en ny process. I denna un­der­pro­cess kan du köra ett annat program med execvp. Detta gör att över­ord­na­de processen kan fortsätta att exekvera sin egen kod, medan den nya processen startar det externa pro­gram­met.

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

I exemplet ovan skapade vi en ny process med fork(). Med hjälp av funk­tio­nen execvp() tar ls över un­der­pro­ces­sen med dess argument. Med waitpid väntar över­pro­ces­sen på att un­der­pro­ces­sen ska slutföras och skriver sedan ut med­de­lan­det.