# 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.

```c
#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](https://www.ionos.com/digitalguide/websites/web-development/learn-c/ "Aprenda a programar em 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.

```c
#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.

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

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.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/execvp/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/execvp/) for AI/LLM consumption.