# execvp en C/C++

Con `execvp`, un programa puede iniciar comandos del sistema como iniciar aplicaciones o ejecutar servicios del sistema. En combinación con la función `fork()`, también se puede llamar a código después de `execvp`.

## ¿Cómo funciona `execvp`?

La principal tarea de `execvp` es transferir el control de un programa a otro sin reiniciar todo el proceso. Esto permite cambiar sin problemas entre diferentes funciones o efectuar comandos externos con argumentos variables. `execvp` es como un director invisible que cambia los escenarios y salta entre diferentes líneas argumentales.

Gracias a la ejecución dinámica de procesos, puedes ajustar la ruta al programa e incluso sus argumentos durante la ejecución. La función `execvp()` se utiliza en llamadas al sistema que requieren tareas complejas como la ejecución de scripts, comandos del sistema, pipelining y redirecciones. Además, contribuye significativamente a aumentar la flexibilidad de los programas en C.

## La sintaxis básica de `execvp`

La sintaxis de `execvp` requiere la ruta del archivo o el nombre del programa a ejecutar y un arreglo de cadenas que contenga los argumentos para dicho programa.

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

- **`const char *command`**: esta es la ruta de archivo o el nombre del programa respectivo. Puede ser una ruta absoluta o relativa. Cuando se usa una ruta relativa, `execvp` busca el archivo en el sistema PATH.
- **`char *argv[]`**: arreglo de cadenas de caracteres que contiene los argumentos para el programa a ejecutar; el arreglo debe terminar con un puntero `NULL` para indicar el final de la lista de argumentos. El primer elemento en `argv` suele ser el nombre del propio programa, seguido de los argumentos.

Las funciones `execvp` y otras funciones de la familia `exec` son específicas de los **sistemas operativos basados en Unix**. La instrucción `#include <unistd.h>` es un archivo de cabecera en la programación en C. Contiene definiciones y declaraciones de funciones que interactúan con el sistema operativo basado en Unix y el control de procesos. Te encontrarás con este archivo frecuentemente al [aprender C](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/tutorial-c/).

## La aplicación práctica de `execvp`

En el programa C presente, utilizamos la función `execvp` del archivo de encabezado `unistd.h` para iniciar el programa externo `ls` con los argumentos `-l` y `/usr/bin`. El arreglo `args` representa los argumentos del programa. Si la función `execvp()` tiene éxito, el proceso actual será reemplazado por el programa externo, y las líneas siguientes serán ignoradas. En caso de error, aparecerá un mensaje de error a través de `perror`, y el programa devolverá el código de estado 1.

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

Con `fork()`, también puedes llamar a instrucciones después de `execvp()`. La función `fork()` crea un nuevo proceso. Esto significa que el código seguirá ejecutándose en el proceso padre, mientras que el nuevo proceso iniciará el 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; 
}
```

La función `execvp()` hace que el proceso hijo tome control con `ls` y sus argumentos. Mientras tanto, el proceso padre espera la finalización del proceso hijo con `waitpid` y luego muestra el mensaje.


This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/execvp/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/execvp/) for AI/LLM consumption.