¿Cómo puede D devolver 0 en caso de éxito y no cero en caso de error si main es nulo?

Question

En D, se define la función main:

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

} 

que sé con certeza que esta función devuelve cero en caso de éxito y que no sea cero en caso de error y sin embargo, se define como no devolver nada. ¿Cuál es la lógica detrás de esto?

Answer 1

función con el tipo de retorno vacío no devuelve ningún valor. No hay nada ilógico si tenemos en cuenta la pila de llamadas es el siguiente:

OS -> D runtime -> main 

La principal función es invocada por el sistema de tiempo de ejecución D, que reconoció que la principal función devuelve nada - y en este caso el éxito de retorno al sistema operativo. En caso de que la función principal se defina con el tipo de retorno int, entonces el tiempo de ejecución D retorna al valor del sistema operativo devuelto por la función principal.

Answer 2

Si se define la función como

int main(...); 

entonces el valor de retorno, que se puede obtener (en bash) usando

echo $? 

será lo que retorno de la función. Si usted no devuelve nada, o definir su función como main

void main(...); 

entonces el estado de salida del comando no está definido. Por alguna razón (no puedo encontrar ninguna documentación sobre esto) siempre hay 200 en mi sistema.

Answer 3

Hay varias firmas posibles para 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) 

Si int es el tipo de retorno, entonces es más o menos lo mismo en C o C++. El valor que devuelve es lo que ve el OS/shell. Si se lanza una excepción, se imprime un seguimiento de pila, y el sistema operativo/shell ve un valor distinto de cero. No sé de qué se trata Puede variar según el tipo de excepción.

Si void es el tipo de devolución, el sistema operativo/shell ve 0. Si se produce una excepción, se imprime un seguimiento de pila y el sistema operativo ve un valor distinto de cero. De nuevo, no sé de qué se trata.

Básicamente, tener void principal no le permite preocuparse por devolver un valor al sistema operativo/shell. Muchos programas no se preocupan en lo más mínimo por devolver el éxito o el fracaso al SO/shell. Entonces, con el vacío, el OS/shell siempre obtiene 0 a menos que se produzca una excepción, lo cual tiene sentido, ya que la única falla del programa en ese punto es si se escapa una excepción main(). Si do se preocupan por devolver el éxito o el fracaso al OS/shell, simplemente use una de las versiones que devuelve int.

La plétora de firmas debido a diferentes tipos de cadenas es que puede utilizar prácticamente cualquiera de los posibles tipos de cadenas como la entrada a main(). main() y main(string[] args) son probablemente los más utilizados.

Answer 4

Lo que dice Alexandrescu es simplemente una abreviatura del código de salida que describí. El cero o no cero devuelto al sistema operativo es un código de salida de proceso (independiente del idioma), no un valor de retorno de función. El sistema operativo no llama directamente al main, y main no regresa directamente al sistema operativo.El compilador D inserta el código de inicio y cierre en su programa para manejar estas interacciones con el SO, al igual que casi todos los demás compiladores para otros lenguajes. Al inicio, por ejemplo, este código repetitivo utiliza algún mecanismo dependiente del sistema operativo para obtener los argumentos de la línea de comandos y los coloca en una matriz D string[] para pasar al main. Al apagar, utiliza el valor de retorno de int main para el código de salida o, para void main, usa su propio valor (0 para el éxito, distinto de cero para excepción no controlada).

En pseudocódigo:

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