Funzioni _exec, _wexec_exec, _wexec Functions

Ogni funzione in questa famiglia carica ed esegue un nuovo processo:Each function in this family loads and executes a new process:

_execl, _wexecl_execl, _wexecl _execv, _wexecv_execv, _wexecv
_execle, _wexecle_execle, _wexecle _execve, _wexecve_execve, _wexecve
_execlp, _wexeclp_execlp, _wexeclp _execvp, _wexecvp_execvp, _wexecvp
_execlpe, _wexeclpe_execlpe, _wexeclpe _execvpe, _wexecvpe_execvpe, _wexecvpe

La lettera alla fine del nome della funzione identifica la modifica.The letter at the end of the function name determines the variation.

Suffisso _exec della funzione_exec function suffix DescrizioneDescription
e envp, matrice di puntatori alle impostazioni di ambiente, viene passato al nuovo processo.envp, array of pointers to environment settings, is passed to the new process.
l Gli argomenti della riga di comando vengono passati singolarmente alla funzione _exec.Command-line arguments are passed individually to _exec function. Si usa in genere quando il numero di parametri per il nuovo processo è noto a priori.Typically used when the number of parameters to the new process is known in advance.
p Per trovare il file da eseguire viene usata la variabile di ambiente PATH.PATH environment variable is used to find the file to execute.
v argv, matrice di puntatori agli argomenti della riga di comando, viene passato a _exec.argv, array of pointers to command-line arguments, is passed to _exec. Si usa in genere quando il numero di parametri per il nuovo processo è variabile.Typically used when the number of parameters to the new process is variable.

NoteRemarks

Ogni funzione _exec carica ed esegue un nuovo processo.Each _exec function loads and executes a new process. Tutte le funzioni _exec usano la stessa funzione di sistema operativo (CreateProcess).All _exec functions use the same operating-system function (CreateProcess). La funzione _exec gestisce automaticamente gli argomenti della stringa con caratteri multibyte in base alle esigenze, riconoscendo le sequenze di caratteri multibyte in base alla tabella codici multibyte attualmente in uso.The _exec functions automatically handle multibyte-character string arguments as appropriate, recognizing multibyte-character sequences according to the multibyte code page currently in use. Le funzioni _wexec sono versioni a caratteri wide delle funzioni _exec.The _wexec functions are wide-character versions of the _exec functions. Le funzioni _wexec si comportano in modo identico alle corrispondenti della famiglia _exec, ma non gestiscono le stringhe di caratteri multibyte.The _wexec functions behave identically to their _exec family counterparts except that they do not handle multibyte-character strings.

Mapping di routine di testo genericoGeneric-Text Routine Mappings

Routine Tchar.hTchar.h routine _UNICODE e _MBCS non definiti_UNICODE and _MBCS not defined _MBCS definito_MBCS defined _UNICODE definito_UNICODE defined
_texecl _execl _execl _wexecl
_texecle _execle _execle _wexecle
_texeclp _execlp _execlp _wexeclp
_texeclpe _execlpe _execlpe _wexeclpe
_texecv _execv _execv _wexecv
_texecve _execve _execve _wexecve
_texecvp _execvp _execvp _wexecvp
_texecvpe _execvpe _execvpe _wexecvpe

Il parametro cmdname specifica il file da eseguire come nuovo processo.The cmdname parameter specifies the file to be executed as the new process. È possibile specificare un percorso completo (dalla radice), un percorso parziale (dalla cartella di lavoro corrente), oppure un nome di file.It can specify a full path (from the root), a partial path (from the current working directory), or a file name. Se cmdname non presenta un'estensione di file o non termina con un punto (.), la funzione _exec cerca il file denominato.If cmdname does not have a file name extension or does not end with a period (.), the _exec function searches for the named file. Se la ricerca ha esito negativo, prova nuovamente con lo stesso nome di base e con l'estensione di file .com e successivamente con .exe, .bat e .cmd.If the search is unsuccessful, it tries the same base name with the .com file name extension and then with the .exe, .bat, and .cmd file name extensions. Se cmdname possiede un estensione di file, nella ricerca viene usata solo l'estensione.If cmdname has a file name extension, only that extension is used in the search. Se cmdname termina con un punto, la funzione _exec cerca cmdname senza estensione di file.If cmdname ends with a period, the _exec function searches for cmdname with no file name extension. _execlp, _execlpe, _execvp e _execvpe cercano cmdname (usando le stesse procedure) nella directory specificata dalla variabile di ambiente PATH._execlp, _execlpe, _execvp, and _execvpe search for cmdname (using the same procedures) in the directories specified by the PATH environment variable. Se cmdname contiene un identificatore di unità o delle barre (ovvero se si tratta di un percorso relativo), la chiamata a _exec cerca soltanto il file specificato; il percorso non viene cercato.If cmdname contains a drive specifier or any slashes (that is, if it is a relative path), the _exec call searches only for the specified file; the path is not searched.

I parametri vengono passati al nuovo processo specificando uno o più puntatori alle stringhe di caratteri come parametri nella chiamata _exec.Parameters are passed to the new process by giving one or more pointers to character strings as parameters in the _exec call. Queste stringhe di caratteri formano l'elenco dei parametri per il nuovo processo.These character strings form the parameter list for the new process. La lunghezza combinata delle impostazioni di ambiente ereditate e delle stringhe che compongono l'elenco dei parametri del nuovo processo non deve superare i 32 KB.The combined length of the inherited environment settings and the strings forming the parameter list for the new process must not exceed 32 kilobytes. Il carattere di terminazione null ('\0') per ogni stringa non è incluso nel conteggio, ma gli spazi (inseriti automaticamente per separare i parametri) vengono contati.The terminating null character ('\0') for each string is not included in the count, but space characters (inserted automatically to separate the parameters) are counted.

Nota

La presenza di spazi incorporati nelle stringhe può causare comportamenti imprevisti; ad esempio, passare a _exec la stringa "hi there" comporterà la presenza nel nuovo processo di due argomenti, "hi" e "there".Spaces embedded in strings may cause unexpected behavior; for example, passing _exec the string "hi there" will result in the new process getting two arguments, "hi" and "there". Se lo scopo è quello di far aprire al nuovo processo un file denominato "hi there", il processo avrà esito negativo.If the intent was to have the new process open a file named "hi there", the process would fail. Per evitarlo, racchiudere la stringa tra virgolette doppie: "\"hi there\"".You can avoid this by quoting the string: "\"hi there\"".

Importante

Non passare input utente a _exec senza verificarne esplicitamente il contenuto.Do not pass user input to _exec without explicitly checking its content. _exec determinerà una chiamata a CreateProcess, per cui è bene tenere presente che i nomi di percorsi non qualificati possono creare vulnerabilità a livello di sicurezza._exec will result in a call to CreateProcess so keep in mind that unqualified path names could lead to potential security vulnerabilities.

Le funzioni _exec convalidano i propri parametri.The _exec functions validate their parameters. Se i parametri previsti sono puntatori Null, stringhe vuote oppure sono omessi, le funzioni _exec richiamano il gestore di parametri non validi come descritto in Convalida dei parametri.If expected parameters are null pointers, empty strings, or omitted, the _exec functions invoke the invalid parameter handler as described in Parameter Validation. Se l'esecuzione può continuare, queste funzioni impostano errno su EINVAL e restituiscono -1.If execution is allowed to continue, these functions set errno to EINVAL and return -1. Non viene eseguito alcun nuovo processo.No new process is executed.

Gli argomenti di tipo puntatore possono essere passati come parametri separati (in _execl, _execle, _execlp e _execlpe) o come o matrice di puntatori (in _execv, _execve, _execvp e _execvpe).The argument pointers can be passed as separate parameters (in _execl, _execle, _execlp, and _execlpe) or as an array of pointers (in _execv, _execve, _execvp, and _execvpe). Almeno un parametro, arg0, deve essere passato al nuovo processo; questo parametro è argv[0] del nuovo processo.At least one parameter, arg0, must be passed to the new process; this parameter is argv[0] of the new process. In genere, questo parametro è una copia di cmdname.Usually, this parameter is a copy of cmdname. (Un valore diverso non produce un errore.)(A different value does not produce an error.)

Le chiamate _execl, _execle, _execlp e _execlpe vengono in genere usate quando il numero di parametri è noto a priori.The _execl, _execle, _execlp, and _execlpe calls are typically used when the number of parameters is known in advance. Il parametro arg0 è generalmente un puntatore a cmdname.The parameter arg0 is usually a pointer to cmdname. I parametri da arg1 a argn puntano alle stringhe di caratteri che costituiscono il nuovo elenco di parametri.The parameters arg1 through argn point to the character strings forming the new parameter list. Un puntatore null deve seguire argn per contrassegnare la fine dell'elenco di parametri.A null pointer must follow argn to mark the end of the parameter list.

Le chiamate _execv, _execve, _execvp e _execvpe sono utili quando il numero di parametri per il nuovo processo è variabile.The _execv, _execve, _execvp, and _execvpe calls are useful when the number of parameters to the new process is variable. I puntatori ai parametri vengono passati come matrice, argv.Pointers to the parameters are passed as an array, argv. Il parametro argv[0] è generalmente un puntatore a cmdname.The parameter argv[0] is usually a pointer to cmdname. I parametri da argv[1] a argv[n] puntano alle stringhe di caratteri che costituiscono il nuovo elenco di parametri.The parameters argv[1] through argv[n] point to the character strings forming the new parameter list. Il parametro argv[n+1] deve essere un puntatore NULL per contrassegnare la fine dell'elenco dei parametri.The parameter argv[n+1] must be a NULL pointer to mark the end of the parameter list.

I file che vengono aperti quando viene effettuata una chiamata _exec rimangono aperti nel nuovo processo.Files that are open when an _exec call is made remain open in the new process. Nelle chiamate _execl, _execlp, _execv e _execvp il nuovo processo eredita l'ambiente del processo chiamante.In _execl, _execlp, _execv, and _execvp calls, the new process inherits the environment of the calling process. Le chiamate _execle, _execlpe, _execve e _execvpe alterano l'ambiente del nuovo processo passando un elenco delle impostazioni di ambiente tramite il parametro envp._execle, _execlpe, _execve, and _execvpe calls alter the environment for the new process by passing a list of environment settings through the envp parameter. envp è una matrice di puntatori a caratteri, ogni elemento della matrice (ad eccezione dell'elemento finale) punta alla stringa di terminazione null che definisce una variabile di ambiente.envp is an array of character pointers, each element of which (except for the final element) points to a null-terminated string defining an environment variable. Tale stringa è in genere in formato NAME=value, dove NAME è il nome di una variabile di ambiente e value è il valore stringa su cui è impostata la variabile.Such a string usually has the form NAME=value where NAME is the name of an environment variable and value is the string value to which that variable is set. (Notare che value non è racchiuso tra virgolette doppie.) L'elemento finale della matrice envp dovrebbe essere NULL.(Note that value is not enclosed in double quotation marks.) The final element of the envp array should be NULL. Quando envp stesso è NULL, il nuovo processo eredita le impostazioni di ambiente del processo chiamante.When envp itself is NULL, the new process inherits the environment settings of the calling process.

Un programma eseguito tramite una delle funzioni _exec viene sempre caricato in memoria come se il campo di allocazione massima nell'intestazione del file .exe fosse stato impostato sul valore predefinito 0xFFFFH.A program executed with one of the _exec functions is always loaded into memory as if the maximum allocation field in the program's .exe file header were set to the default value of 0xFFFFH.

Le chiamate _exec non mantengono le modalità di conversione dei file aperti.The _exec calls do not preserve the translation modes of open files. Se il nuovo processo deve usare file ereditati dal processo chiamante, usare la routine _setmode per impostare la modalità di traduzione di questi file desiderata.If the new process must use files inherited from the calling process, use the _setmode routine to set the translation mode of these files to the desired mode. È necessario scaricare (usando fflush o _flushall) o chiudere esplicitamente qualsiasi flusso prima della chiamata di funzione _exec.You must explicitly flush (using fflush or _flushall) or close any stream before the _exec function call. Le impostazioni dei segnali non vengono mantenute nei nuovi processi creati dalle chiamate alle routine _exec.Signal settings are not preserved in new processes that are created by calls to _exec routines. Le impostazioni dei segnali del nuovo processo vengono reimpostate sui valori predefiniti.The signal settings are reset to the default in the new process.

EsempioExample

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

Eseguire il programma seguente per eseguire Crt_args.exe:Run the following program to execute Crt_args.exe:

// 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 );  
}  

RequisitiRequirements

Intestazione: process.hHeader: process.h

Vedere ancheSee Also

Controllo processo e ambiente Process and Environment Control
abort abort
atexit atexit
exit, _Exit, _exit exit, _Exit, _exit
_onexit, _onexit_m _onexit, _onexit_m
Funzioni _spawn, _wspawn _spawn, _wspawn Functions
system, _wsystemsystem, _wsystem