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 aplicativos 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 normalmente.

O que a função execvp faz?

A principal papel da função execvp é transferir o controle de um programa para outro sem reinicializar todo o processo. Ela permite alternar, de forma contínua, entre diferentes funcionalidades ou executar comandos externos com argumentos variáveis. A função execvp atua como um diretor invisível que troca os cenários e salta entre diferentes e salta entre diferentes processos.

Graças à execução dinâmica de processos, você pode ajustar o caminho para o programa e até mesmo seus argumentos 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 redirecionamentos. Ela contribui significativamente para aumentar a flexibilidade 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 argumentos 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 especí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 argumentos para o programa a ser executado; o array deve terminar com um ponteiro NULL para indicar o fim da lista de argumentos. O primeiro item em argv geralmente é o nome do próprio programa, seguido pelos argumentos.

As funções execvp e outras da família exec são específicas para sistemas operacionais baseados em Unix. A diretiva #include <unistd.h> é um cabeçalho na programação C que contém definições e declarações de funções que interagem com o sistema operacional Unix e o controle de processos. Esses conceitos são frequentemente encontrados ao aprender linguagem C.

Exemplos de uso da função execvp

No presente programa em C, utilizamos a função execvp() do arquivo de cabeçalho unistd.h para iniciar o programa externo ls com os argumentos -l e /usr/bin. O array args representa os argumentos do programa. Se a função execvp() for bem-sucedida, o processo atual será substituído pelo programa externo, e as linhas subsequentes não serão executadas. 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 instruções após execvp() também. A função fork() cria um novo processo, permitindo 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 argumentos 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.