_exec, _wexec funções

Cada função nesta família carrega e executa um novo processo:

Letra no participante do nome da função determina a variação.

Comentários

Cada _exec função carrega e executa um novo processo. All _exec funções usam a mesma função de sistema operacional. The _exec funções de tratam automaticamente sistema autônomo argumentos de seqüência de caractere multibyte conforme apropriado, reconhecendo seqüências de caractere de multibyte de acordo com para a página de código multibyte atualmente em uso. The _wexec funções são versões de caractere largo do _exec funções. The _wexec funções se comportam de forma idêntica para seus _exec equivalentes da família, exceto pelo fato de que eles não manipulam seqüências de caractere de multibyte.

Mapeamentos de rotina de texto genérica

Quando uma telefonar para um _exec função for bem-sucedida, o novo processo é colocado na memória ocupada anteriormente pelo processo de telefonar. Memória suficiente deve estar disponível para carregar e executar o novo processo.

The cmdname parâmetro especifica o arquivo a ser executado sistema autônomo o novo processo. Ele pode especificar um caminho completo (de raiz), um caminho parcial (do diretório de trabalho corrente) ou um nome de arquivo.If cmdname não tem uma extensão de nome de arquivo ou não termina com um ponto (.), o _exec função de pesquisa no arquivo nomeado. Se a Pesquisar não obtiver êxito, ele tenta o mesmo nome de base com a extensão de nome de arquivo .com e, em seguida, com o .exe, .bat e .cmd as extensões de nome de arquivo.If cmdname tem uma extensão de nome de arquivo, somente essa extensão é usado na Pesquisar. If cmdname termina com um período, o _exec função de procura cmdname sem extensão de nome de arquivo. _execlp, _execlpe, _execvp, e _execvpe Procurar cmdname (usando os mesmos procedimentos) nos diretórios especificados pela PATH variável de ambiente. If cmdname contém um especificador de unidade ou quaisquer barras (ou seja, se ele é um caminho relativo), o _exec telefonar procura apenas o arquivo especificado; o caminho não é pesquisado.

Parâmetros são passados para o novo processo oferecendo ponteiros de uma ou mais seqüências de caractere sistema autônomo parâmetros no _exec Chame. Esses formulário seqüências de caractere a parâmetro lista para o novo processo.O comprimento combinado das configurações do ambiente herdado e as seqüências de caracteres que formam a lista de parâmetros para o novo processo não deve exceder 32 kilobytes.O caractere nulo de terminação ('\0') para cada seqüência de caracteres não está incluído na contagem, mas caracteres de espaço (inseridos automaticamente para separar os parâmetros) são contadas.

Observação:

Espaços incorporados em seqüências de caracteres podem causar um comportamento inesperado; por exemplo, passando _exec a seqüência de caracteres "hi there" fará com que o novo processo Obtendo dois argumentos: "hi" e "there". Se a intenção era para que o novo processo de em em aberto um arquivo chamado "Olá lá", o processo falhará.Você pode evitar isso citando a seqüência de caracteres: "\"hi there\"".

Observação de segurança:
Não passe a entrada do usuário para _exec sem verificar explicitamente se seu conteúdo. _exec resultará em uma telefonar para CreateProcess assim, tenha em mente esse caminho não qualificado nomes podem levar a vulnerabilidades de segurança potenciais.

In Visual C++ 2005, o _exec funções validar seus parâmetros. Se esperava parâmetros são nulo ponteiros, seqüências de caracteres vazia ou omitido, a _exec funções de chamar o manipulador de parâmetro inválido conforme descrito em Validação de parâmetro. Se a execução for permitida para continuar, essas funções conjunto errno para EINVAL e retornar -1. Nenhum novo processo é executado.

sistema autônomo ponteiros de argumento podem ser passados sistema autônomo parâmetros separados (em _execl, _execle, _execlp, e _execlpe) ou sistema autônomo uma matriz de ponteiros (pol _execv, _execve, _execvp, e _execvpe). Pelo menos um parâmetro, arg0, deve ser passado para o novo processo; esse parâmetro é argv[0] do novo processo. Normalmente, esse parâmetro é uma cópia de cmdname. (Um valor diferente não produz um erro.)

The _execl, _execle, _execlp, e _execlpe chamadas são geralmente usadas quando o número de parâmetros é conhecido antecipadamente. O parâmetro arg0 geralmente é um ponteiro para cmdname. Os parâmetros de arg1 por meio de argn aponte para formar a nova lista de parâmetro de seqüências de caractere. Um ponteiro nulo deve seguir argn para marcar o participante da lista de parâmetro.

The _execv, _execve, _execvp, e _execvpe chamadas são úteis quando o número de parâmetros para o novo processo é variável. Ponteiros para sistema autônomo parâmetros são passados sistema autônomo uma matriz, argv. O parâmetro argv[0] é geralmente um ponteiro para cmdname. The parameters argv[1] through argv[n] point to the character strings forming the new parameter list.The parameter argv[n+1] must be a NULL pointer to mark the end of the parameter list.

Arquivos que estão abertos quando um _exec telefonar é feita a permanecer em aberto no novo processo. In _execl, _execlp, _execv, e _execvp chamadas, o novo processo herda o ambiente do processo de chamada. _execle, _execlpe, _execve, e _execvpe chamadas de alteram o ambiente para o novo processo, passando uma lista das configurações de ambiente por meio do envp parâmetro. envp uma matriz de ponteiros de caractere, cada elemento do qual (exceto para o elemento final) aponta para uma seqüência de caracteres terminada com caractere nulo é definir uma variável de ambiente. Uma seqüência de caracteres geralmente tem a forma NAME=value onde NAME é o nome de uma variável de ambiente e value é o valor de seqüência de caracteres para o qual essa variável está definida. (Observe que value não está entre aspas duplas.) O elemento final do envp a matriz deve ser NULL. Quando envp está NULL, o novo processo herda as configurações de ambiente do processo de chamada.

Um programa executado com um a _exec funções é sempre carregado na memória sistema autônomo se o campo alocação máxima no cabeçalho do arquivo .exe do programa estivesse definido sistema autônomo o valor padrão de 0xFFFFH.

The _exec chamadas não preservam os modos de conversão de arquivos abertos. Se o novo processo deve usar arquivos herdados do processo de chamada, use o _setmode rotina para conjunto o modo de conversão desses arquivos para o modo desejado.Você deve liberar explicitamente (usando fflush ou _flushall) ou qualquer fluxo antes de fechar o _exec telefonar de função. Configurações de sinal não são preservadas em novos processos criados por chamadas para _exec rotinas. As configurações de sinal são redefinidas para padrão no novo processo.

Exemplo

// crt_args.c
// Illustrates the following variables used for accessing
// command-line arguments and environment variables:
// argc  argv  envp
// This program will be executed by crt_exec which follows.


#include <stdio.h>

int main( int argc,  // Number of strings in array argv
 char *argv[],       // Array of command-line argument strings
 char **envp )       // Array of environment variable strings
{
    int count;

    // Display each command-line argument.
    printf( "\nCommand-line arguments:\n" );
    for( count = 0; count < argc; count++ )
        printf( "  argv[%d]   %s\n", count, argv[count] );

    // Display each environment variable. 
    printf( "\nEnvironment variables:\n" );
    while( *envp != NULL )
        printf( "  %s\n", *(envp++) );

    return;
}

executar o programa executar Crt_args.exe seguinte:

// crt_exec.c
// Illustrates the different versions of exec, including
//      _execl          _execle          _execlp          _execlpe
//      _execv          _execve          _execvp          _execvpe
//
// Although CRT_EXEC.C can exec any program, you can verify how 
// different versions handle arguments and environment by 
// compiling and specifying the sample program CRT_ARGS.C. See 
// "_spawn, _wspawn Functions" for examples of the similar spawn 
// functions.


#include <stdio.h>
#include <conio.h>
#include <process.h>

char *my_env[] =     // Environment for exec?e
{
   "THIS=environment will be",
   "PASSED=to new process by",
   "the EXEC=functions",
   NULL
};

int main( int ac, char* av[] )
{
   char *args[4];
   int ch;
   if( ac != 3 ){
      fprintf( stderr, "Usage: %s <program> <number (1-8)>\n", av[0] );
      return;
   }

   // Arguments for _execv? 
   args[0] = av[1];
   args[1] = "exec??";
   args[2] = "two";
   args[3] = NULL;

   switch( atoi( av[2] ) )
   {
   case 1:
      _execl( av[1], av[1], "_execl", "two", NULL );
      break;
   case 2:
      _execle( av[1], av[1], "_execle", "two", NULL, my_env );
      break;
   case 3:
      _execlp( av[1], av[1], "_execlp", "two", NULL );
      break;
   case 4:
      _execlpe( av[1], av[1], "_execlpe", "two", NULL, my_env );
      break;
   case 5:
      _execv( av[1], args );
      break;
   case 6:
      _execve( av[1], args, my_env );
      break;
   case 7:
      _execvp( av[1], args );
      break;
   case 8:
      _execvpe( av[1], args, my_env );
      break;
   default:
      break;
   }

   // This point is reached only if exec fails. 
   printf( "\nProcess was not execed." );
   exit( 0 );
}

Equivalente do NET Framework

• Classe sistema::Diagnóstico::processo

• Classe sistema::Diagnóstico::ProcessStartInfo

Consulte também

Referência

Processo e ambiente de controle

anular

atexit

sair, _exit

_onexit, _onexit_m

_spawn, _wspawn funções

sistema, _wsystem