# Sådan bruges execvp() i C og C++

Med `execvp` kan et program starte systemkommandoer, såsom at starte applikationer eller udføre systemtjenester. Når det kombineres med `fork()`, kan koden også kaldes efter `execvp`.

## Hvordan fungerer `execvp`?

Hovedformålet med `execvp` er at give et program mulighed for at styre et andet uden at genstarte hele processen. Dette muliggør problemfri skift mellem forskellige funktioner eller udførelse af eksterne kommandoer med variable argumenter. `execvp` fungerer som en usynlig instruktør, der skifter kulisse og springer frem og tilbage mellem forskellige historier.

Dynamisk procesudførelse giver dig mulighed for at justere programstien og dens argumenter under kørsel. Funktionen `execvp()` bruges i systemkald, der kræver komplekse opgaver såsom scriptudførelse, systemkommandoer, pipelining og omdirigeringer. Det forbedrer fleksibiliteten i C-programmer betydeligt.

## Hvad er syntaksen for `execvp`?

Funktionen `execvp` kræver to parametre: filstien eller navnet på det program, du vil køre, og en række strenge med argumenterne til det pågældende program.

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

- **`const char *command`**: Dette er filstien eller navnet på det program, du vil køre. Det kan være en absolut sti eller en relativ sti. Hvis der bruges en relativ sti, `execvp` søger efter filen i systemets PATH.
- **`char *argv[]`**: En række strenge, der indeholder argumenterne for det program, der skal køres. Rækken skal slutte med en `NULL` pointer for at angive slutningen af argumentlisten. Den første post i `argv` er normalt navnet på selve programmet efterfulgt af argumenterne.

Funktionen `execvp` og andre funktioner fra familien `exec` er specifikke for **Unix-baserede operativsystemer**. Sætningen `#include <unistd.h>` er en header-fil i C-programmering, der indeholder definitioner og deklarationer af funktioner til interaktion med et Unix-baseret operativsystem og processtyring. Du vil støde på denne fil mange gange, når du lærer at skrive kode i C.

## Eksempel på brug af `execvp`

I eksemplet nedenfor bruger vi funktionen `execvp()` fra headerfilen unistd.h til at starte det eksterne program `ls` med argumenterne `-l` og `/usr/bin`. Arrayet `args` står for programmets argumenter. Hvis funktionen `execvp()` lykkes, erstattes den aktuelle proces af det eksterne program, og de efterfølgende linjer ignoreres. I tilfælde af en fejl vises en fejlmeddelelse via `perror`, og programmet returnerer statuskoden 1.

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

Ved hjælp af `fork()` kan du oprette en ny proces. I denne underproces kan du køre et andet program ved hjælp af `execvp`. Dette gør det muligt for overprocessen at fortsætte med at udføre sin egen kode, mens den nye proces starter det eksterne program.

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

I eksemplet ovenfor oprettede vi en ny proces ved hjælp af `fork()`. Ved hjælp af funktionen `execvp()` overtager `ls` underprocessen med dens argumenter. Med `waitpid` venter overprocessen på, at underprocessen afsluttes, og udskriver derefter meddelelsen.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/execvp/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/execvp/) for AI/LLM consumption.