In che modo D può restituire 0 in caso di esito positivo e diverso da zero in caso di errore se principale è vuoto?

Question

In D, la funzione viene definita main:

void main(/*perhaps some args but I do not remember*/) 
{ 

} 

so per certo che questa funzione restituisce zero in caso di successo e diverso da zero in caso di fallimento e tuttavia è definito come non tornare nulla. Qual è la logica dietro?

Answer 1

La funzione con tipo di reso vuoto non restituisce alcun valore. Non c'è niente di illogico se si considera stack di chiamate simile al seguente:

OS -> D runtime -> main 

La funzione principale viene richiamato dal sistema di runtime D, che ha riconosciuto che la funzione principale non restituisce nulla - e in questo caso il ritorno successo al sistema operativo. Nel caso in cui la funzione principale sia definita con il tipo restituito int, il runtime D ritorna al valore OS restituito dalla funzione principale.

Answer 2

Se si definisce la funzione come

int main(...); 

allora il valore di ritorno, che si può ottenere (in bash) utilizzando

echo $? 

sarà tutto ciò che si torna dalla funzione. Se non riesci a tornare nulla, o si definisce la funzione main come

void main(...); 

quindi lo stato di uscita del comando non è definito. Per qualche ragione (non riesco a trovare alcuna documentazione su questo) è sempre 200 sul mio sistema.

Answer 3

Ci sono diversi possibili firme per main():

void main() 
void main(string[] args) 
void main(char[][] args) 
void main(wstring[] args) 
void main(wchar[][] args) 
void main(dstring[] args) 
void main(dchar[][] args) 
int main() 
int main(string[] args) 
int main(char[][] args) 
int main(wstring[] args) 
int main(wchar[][] args) 
int main(dstring[] args) 
int main(dchar[][] args) 

Se int è il tipo di ritorno, allora è praticamente la stessa cosa in C o C++. Il valore restituito è ciò che vede il sistema operativo/shell. Se viene generata un'eccezione, viene stampata una traccia dello stack e il sistema operativo/shell vede un valore diverso da zero. Non so cosa sia. Può variare in base al tipo di eccezione.

Se vuoto è il tipo restituito, il sistema operativo/shell visualizza 0. Se viene generata un'eccezione, viene stampata una traccia dello stack e il sistema operativo visualizza un valore diverso da zero. Di nuovo, non so cosa sia.

Essenzialmente, con void principale non ti devi preoccupare di restituire un valore all'OS/shell. Molti programmi non sono minimamente interessati al ritorno o al fallimento del sistema operativo/shell. Quindi, con void, il sistema operativo/shell ottiene sempre 0 a meno che non venga lanciata un'eccezione, il che ha senso, poiché l'unico errore del programma a quel punto è se un'eccezione fuoriesce dallo main(). Se si fare si preoccupa di restituire il successo o l'errore al sistema operativo/shell, quindi è sufficiente utilizzare una delle versioni che restituisce int.

La pletora di firme a causa di diversi tipi di stringhe è che è possibile utilizzare praticamente tutti i tipi di stringa possibili come input per main(). main() e main(string[] args) sono probabilmente i più usati.

Answer 4

Quello che Alexandrescu sta dicendo è semplicemente una scorciatoia per il codice di uscita che ho descritto. Lo zero o il diverso zero restituito al sistema operativo è un codice di uscita del processo (indipendente dalla lingua), non un valore restituito dalla funzione. Il sistema operativo non chiama direttamente main e main non torna direttamente al sistema operativo.Il compilatore D inserisce il codice di avvio e di arresto nel programma per gestire queste interazioni con il sistema operativo, analogamente a quasi tutti gli altri compilatori per altre lingue. All'avvio, ad esempio, questo codice boilerplate utilizza un meccanismo dipendente dal sistema operativo per ottenere gli argomenti della riga di comando e li inserisce in una serie D string[] da passare a main. All'arresto, utilizza il valore restituito da int main per il codice di uscita oppure, per void main, utilizza il proprio valore (0 per il successo, diverso da zero per l'eccezione non gestita).

In pseudocodice:

// Generated by compiler 
void _realMain() 
{ 
    // OS-dependent; probably calls GetCommandLineW 
    // and CommandLineToArgvW on Windows, for example 
    string[] cmdLineArgs = createArgArray(); 

    int exitCode = 0; // Assume success 
    try 
    { 
     // static if selects only one call to main for compilation, 
     // depending on main's return type. 

     // If main has been written to return int, use its value for the exit code 
     static if (main returns int) 
      exitCode = main(cmdLineArgs); 
     // If main has been declared void, just run it and keep the exit code of 0 
     else 
      // void main: *doesn't return anything* 
      main(cmdLineArgs); 
    } 
    catch 
    { 
     // Unhandled exception results in non-zero exit code 
     exitCode = 1; 
     printStackTrace(); 
    } 

    // OS-dependent process shutdown function. 
    // This is where the exit code is "returned" to the OS. 
    // Note it *does not* use the return keyword to do so. 
    // Calling the OS's function to kill the current process 
    // does not return, because the process is dead by the 
    // time the function has finished! 
    exitProcess(exitCode); 
    // In particular, no code *after* the exitProcess line will run. 
}