Função execvp em C/C++

Ao usar a função execvp, você faz com que um programa substitua um processo atual por um novo processo que executa comandos de sistema, iniciando apli­ca­ti­vos ou serviços, por exemplo. Quando combinada com a função fork(), execvp é capaz de criar um processo filho que executa o comando, enquanto o processo pai continua em execução nor­mal­mente.

O que a função execvp faz?

A principal papel da função execvp é trans­fe­rir o controle de um programa para outro sem rei­ni­ci­a­li­zar todo o processo. Ela permite alternar, de forma contínua, entre di­fe­ren­tes fun­ci­o­na­li­da­des ou executar comandos externos com ar­gu­men­tos variáveis. A função execvp atua como um diretor invisível que troca os cenários e salta entre di­fe­ren­tes e salta entre di­fe­ren­tes processos.

Graças à execução dinâmica de processos, você pode ajustar o caminho para o programa e até mesmo seus ar­gu­men­tos durante a execução. A função execvp() é utilizada em chamadas de sistema que envolvem tarefas complexas, como na execução de scripts, em comandos do sistema, em pipelines e em re­di­re­ci­o­na­men­tos. Ela contribui sig­ni­fi­ca­ti­va­mente para aumentar a fle­xi­bi­li­dade dos programas em C.

Sintaxe básica da função execvp

A sintaxe da função execvp requer o caminho do arquivo ou nome do programa a ser executado e uma matriz de strings contendo os ar­gu­men­tos para esse programa.

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

• const char *command: Este é o caminho do arquivo ou o nome do programa es­pe­cí­fico. Ele pode ser um caminho absoluto ou relativo. Quando usando um caminho relativo, execvp procura pelo arquivo no PATH do sistema.
• char *argv[]: Um array de strings que contém os ar­gu­men­tos para o programa a ser executado; o array deve terminar com um ponteiro NULL para indicar o fim da lista de ar­gu­men­tos. O primeiro item em argv ge­ral­mente é o nome do próprio programa, seguido pelos ar­gu­men­tos.

As funções execvp e outras da família exec são es­pe­cí­fi­cas para sistemas ope­ra­ci­o­nais baseados em Unix. A diretiva #include <unistd.h> é um cabeçalho na pro­gra­ma­ção C que contém de­fi­ni­ções e de­cla­ra­ções de funções que interagem com o sistema ope­ra­ci­o­nal Unix e o controle de processos. Esses conceitos são fre­quen­te­mente en­con­tra­dos ao aprender linguagem C.

Exemplos de uso da função execvp

No presente programa em C, uti­li­za­mos a função execvp() do arquivo de cabeçalho unistd.h para iniciar o programa externo ls com os ar­gu­men­tos -l e /usr/bin. O array args re­pre­senta os ar­gu­men­tos do programa. Se a função execvp() for bem-sucedida, o processo atual será subs­ti­tuído pelo programa externo, e as linhas sub­se­quen­tes não serão exe­cu­ta­das. Em caso de erro, uma mensagem será exibida por perror, e o programa retornará o código de status 1.

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

Com fork(), você pode executar ins­tru­ções após execvp() também. A função fork() cria um novo processo, per­mi­tindo que o código continue a ser executado no processo pai enquanto o novo processo executa o programa externo.

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

Primeiro, criamos um novo processo usando fork(). O processo filho assume o programa ls com seus ar­gu­men­tos usando a função execvp(). O processo pai espera então pelo término do processo filho com waitpid e exibe uma mensagem após isso.