Função EXECV na linguagem C

Existem várias maneiras e funções para iniciar os processos de um programa. Cada um deles oferece soluções diferentes para o programador, dependendo das necessidades do caso específico.

O Execxx () a família é um conjunto de funções do sistema que são definidas no “unistd.H ”Cabeçalho para executar um processo de dentro de um programa. Essa família de funções nos permite enviar os argumentos de entrada para o executável que o chama, e é por isso que é um recurso muito útil para a interação entre os processos.

Nisso Linux Dica artigo, você aprenderá tudo sobre o EXECV () função na linguagem C. Veremos sua sintaxe, a descrição teórica de como ela funciona, os argumentos de entrada e saída e o tipo de dados que cada um deles processa. Você também aprenderá como criar e usar as matrizes de cordas e ponteiros que fazem parte dos argumentos de entrada dessa família de funções e são passados ​​para o processo de chamada.

Em seguida, aplicamos o que aprendemos em um exemplo prático que mostra a implementação correta e o chamado do EXECV () função.

Sintaxe da função EXECV () na linguagem C

int Execv (const char *caminho, char *const argv []);

Descrição da função EXECV () na linguagem C

O EXECV () A função executa um processo de outro processo ou programa. Esta função executa o arquivo ou executável que é especificado no *caminho argumento. Esta entrada deve conter o caminho absoluto ou relativo do arquivo executável no formato String.

O *argv [] O argumento é uma variedade de ponteiros a cordas onde cada string é um argumento de entrada que é passado para o processo a ser executado. O primeiro ponteiro da matriz deve sempre apontar para uma string que contém o nome do arquivo executável e o último ponteiro deve ser sempre nulo. Quando EXECV () é chamado, o processo do qual foi chamado é encerrado, reescrito e substituído pelo novo processo na parte alocada da memória e com o mesmo id.

Se a função for executada com sucesso, ela não retornará. Se retornar, é porque ocorre um erro. Os erros que essa função pode gerar são variados, variando desde o caminho de arquivo executável inexistente até as permissões negadas.

O erro pode ser identificado recuperando seu valor do errno variável global. Na parte posterior, veremos uma seção especial que explica os erros mais comuns dessa função e sua identificação.

A família de Execxx () funções são definidas no “unistd.H ”cabeçalho. Para usá -los, devemos incluí -los em nosso “.Arquivo C ”da seguinte maneira:

#incluir

Como executar um processo de um programa usando a função EXECV () na linguagem C

Neste exemplo, explicaremos como usar o EXECV () função para executar um processo e passar os argumentos de entrada de um programa para outro.

Para fazer isso, criamos dois códigos muito simples. Uma é o processo pai que chama a função EXECV () para executar o processo infantil. Quando o EXECV () A função inicia o processo infantil, passa por três argumentos de entrada na forma de uma string que o processo filho recupera e exibe no shell.

Processo infantil

O processo infantil é uma peça simples de código que imprime o “Eu sou o processo infantil ” mensagem, recupera os argumentos de entrada enviados pelo processo pai e os exibe no shell. Aqui está o código para o processo infantil:

#incluir
#incluir
#incluir
int main (int argc, char *argv [])

printf ("Eu sou o processo infantil");
printf ("argumento 1: %s \ n", argv [1]);
printf ("argumento 2: %s \ n", argv [2]);
printf ("argumento 3: %s \ n", argv [3]);

Compilamos esse código e salvamos sua produção em "documentos" sob o nome "criança" com o ".Extensão de bin ”, conforme mostrado no seguinte:

~ $ gcc documentos/filho.Documentos C -O/criança.BIN

Dessa forma, salvamos o arquivo executável infantil em "documentos". O caminho deste executável é o argumento de entrada, caminho, Ao ligar EXECV () No processo pai.

Processo pai

O processo pai é aquele do qual chamamos de EXECV () função para executar o processo infantil. Neste código, definimos uma variedade de ponteiros para as cordas que representam os argumentos de entrada para o processo de que o EXECV () função abre.

Você pode ver como criar corretamente uma variedade de dicas para as cordas na ilustração a seguir. Nesse caso, consiste em 5 ponteiros e é chamado arg_ptr [].

char *arg_ptr [5];

Uma vez definido a variedade de ponteiros, cada ponteiro deve receber uma string que contém o argumento de entrada que enviamos ao processo infantil.

Você pode ver como atribuir cada ponteiro ao seu argumento correspondente no formato da string na seguinte ilustração:

arg_ptr [0] = "criança.C ";
arg_ptr [1] = "\ nhello de";
arg_ptr [2] = "Process 2";
arg_ptr [3] = null;

Outra maneira de atribuir as cordas à matriz de ponteiros é incluir as cordas em aparelhos encaracolados e separá -las com vírgulas:

arg_ptr [] = "criança.c, "\ nhello de", "Process 2", null;

Depois de definir a variedade de ponteiros para cada argumento, o próximo passo é chamar o EXECV () função, passando a string que contém o caminho absoluto ou relativo do arquivo executável como o primeiro argumento e a matriz de strings arg_ptr []Como o segundo argumento.

Você pode ver o "principal" completo do processo pai na seguinte ilustração:

#incluir
#incluir
#incluir
#incluir
#incluir
int main ()
printf ("\ n \ ni sou o processo pai \ n");
char *arg_ptr [5];
arg_ptr [0] = "criança.C ";
arg_ptr [1] = "\ nhello de";
arg_ptr [2] = "Process 2";
arg_ptr [3] = null;
EXECV ("/Home/Linuxhint/Child.bin ", arg_ptr);

Nós compilamos este código que especifica o caminho do “.Arquivo C ”e o nome do Out.

~ $ gcc documentos/pai.C -O padrão

Então, nós executamos a saída.

~ $ ./ padrão

O processo pai exibe o “Eu sou o processo pai” mensagem, cria a matriz de string atribuindo uma string para cada argumento de entrada que é passado para o próximo processo e chama o EXECV () função. Se o EXECV () A função é executada com sucesso, a criança.O executável do bin substitui o processo pai e assume seu ID e memória alocada, para que essa ação não possa ser desfeita.

O processo infantil exibe o “Eu sou o processo infantil” Mensagem e recupera cada um dos argumentos de entrada que são passados ​​pelo processo pai para exibir no console de comando.

Como reconhecer possíveis erros ao usar a função EXECV ()

O EXECV () A função não retorna se for executada com sucesso. Se retornar ao código que o chamou, ocorreu um erro. Os erros que podem ser gerados por esta função são diversos, uma vez que a operação depende de dois processos diferentes, caminhos de arquivo, permissões de acesso e assim por diante.

A maneira de identificar o erro é através do errno variável global. Esta variável é um número inteiro e é definida no “errno.H ”cabeçalho. Cada vez que ocorre um erro, um valor numérico que representa um erro específico é armazenado nele.

Em seguida, analisamos as definições e o valor representativo dos possíveis erros que podem ocorrer ao usar esta função:

Nós geramos um erro na patern.Código C, indicando um caminho de arquivo inexistente para o EXECV () função. Em seguida, use a função Printf para exibir o código de erro obtido do errno variável no console:

#incluir
#incluir
#incluir
#incluir
#incluir
int main ()
printf ("\ n \ ni sou o processo pai \ n");
char *arg_ptr [5];
arg_ptr [0] = "criança.C ";
arg_ptr [1] = "\ nhello de";
arg_ptr [2] = "Process 2";
arg_ptr [3] = null;
EXECV ("/home/linuxhint/não existente.bin ", arg_ptr);
printf ("erro: %i \ n", errno);

Como podemos ver na figura a seguir, a função EXECV () não conseguiu encontrar o arquivo com o caminho especificado e, portanto, retorna ao processo pai com o valor 2 na variável ERRNO, que corresponde ao ““Não existe tal arquivo ou diretório" erro.

Conclusão

Nisso Linux Dica artigo, explicamos como usar o EXECV () função no idioma C para iniciar um processo de outro processo. Explicamos a operação teórica de EXECV () e mostrou como declarar os argumentos de entrada.

Em seguida, implementamos o que aprendemos em um exemplo, mostrando como criar o programa pai e o processo filho, passando os argumentos de um para o outro. Além disso, vimos uma seção especial onde mostramos os erros mais comuns dessa função e como identificá -los usando a variável errno.

Esperamos que este artigo seja útil para você. Para obter mais artigos sobre as dicas de idioma C e Linux, use o mecanismo de pesquisa em nosso site.