# Hvordan bruke execvp() i C og C++

Med `execvp` kan et program starte systemkommandoer, for eksempel starte applikasjoner eller utføre systemtjenester. Når det kombineres med funksjonen `fork()`, kan koden også kalles etter `execvp`.

## Hvordan fungerer `execvp`?

Hovedformålet med `execvp` er å la ett program kontrollere et annet uten å starte hele prosessen på nytt. Dette muliggjør sømløs veksling mellom ulike funksjoner eller utførelse av eksterne kommandoer med variable argumenter. `execvp` fungerer som en usynlig regissør, som endrer kulissene og hopper frem og tilbake mellom ulike historielinjer.

Dynamisk prosessutførelse lar deg justere programbanen og dens argumenter under kjøring. Funksjonen `execvp()` brukes i systemkall som krever komplekse oppgaver som skriptutførelse, systemkommandoer, pipelining og omdirigeringer. Den forbedrer fleksibiliteten til C-programmer betydelig.

## Hva er syntaksen til `execvp`?

Funksjonen `execvp` trenger to parametere: filstien eller navnet på programmet du vil kjøre, og en strengmatrise med argumentene for det programmet.

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

- **`const char *command`**: Dette er filstien eller navnet på programmet du vil kjøre. Det kan være en absolutt sti eller en relativ sti. Hvis en relativ sti brukes, søker `execvp` etter filen i systemets PATH.
- **`char *argv[]`**: En strengmatrise som inneholder argumentene for programmet som skal kjøres. Matrisen må avsluttes med en `NULL` for å indikere slutten på argumentlisten. Den første oppføringen i `argv` er vanligvis navnet på selve programmet, etterfulgt av argumentene.

Funksjonene `execvp` og andre funksjoner fra familien `exec` er spesifikke for **Unix-baserte operativsystemer**. Setningen `#include <unistd.h>` er en header-fil i C-programmering som inneholder definisjoner og deklarasjoner av funksjoner for samhandling med et Unix-basert operativsystem og prosesskontroll. Du vil støte på denne filen ofte når du lærer å skrive kode i C.

## Eksempel på hvordan du bruker `execvp`

I eksemplet nedenfor skal vi bruke funksjonen `execvp()` fra headerfilen unistd.h til å starte det eksterne programmet `ls` med argumentene `-l` og `/usr/bin`. Arrayen `args` står for programmets argumenter. Hvis funksjonen `execvp()` lykkes, vil den aktuelle prosessen erstattes av det eksterne programmet, og de påfølgende linjene vil bli ignorert. I tilfelle en feil oppstår, vil en feilmelding vises via `perror`, og programmet vil returnere statuskoden 1.

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

Ved hjelp av `fork()` kan du opprette en ny prosess. I denne underprosessen kan du kjøre et annet program ved hjelp av `execvp`. Dette gjør at overprosessen kan fortsette å utføre sin egen kode, mens den nye prosessen starter det eksterne programmet.

```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 opprettet vi en ny prosess ved hjelp av `fork()`. Ved hjelp av funksjonen `execvp()` overtar `ls` underprosessen med sine argumenter. Med `waitpid` venter overprosessen på at underprosessen skal fullføres, og sender deretter ut meldingen.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/execvp/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/execvp/) for AI/LLM consumption.