¿Por qué verificar si (* argv == NULL)?

En la clase de estructuras de datos que tomo actualmente, se nos ha asignado la tarea de escribir un rastreador web en C ++. Para darnos una ventaja, el profesor nos proporcionó un progtwig para obtener la fuente de una URL determinada y un analizador HTML simple para eliminar las tags. La función principal de este progtwig acepta argumentos y, por lo tanto, utiliza argc / argv. El código utilizado para verificar los argumentos es el siguiente:

// Process the arguments if (!strcmp(option, "-h")) { // do stuff... } else if (!strcmp(option, "")) { // do stuff... } else if (!strcmp(option, "-t")) { // do stuff... } else if (!strcmp(option, "-a")) { // do stuff... } if ( *argv == NULL ) { exit(1); } 

Donde “opción” se ha rellenado con el conmutador en argv [1], y argv [2] y superior tiene los argumentos restantes. El primer bloque lo entiendo bien, si el interruptor es igual a la cadena, haga lo que sea en función del interruptor. Me pregunto cuál es el propósito del último si el bloque es sin embargo.

Podría ser que mi C ++ esté algo oxidado, pero me parece recordar que * argv es equivalente a argv [0], lo que básicamente significa que está comprobando que los argumentos existan. Excepto que tenía la impresión de que argv [0] siempre (al menos en la mayoría de las implementaciones) contenía el nombre del progtwig que se está ejecutando. Se me ocurre que argv [0] podría ser nulo si argc es igual a 0, pero al buscar en Google no pude encontrar una sola publicación que determine si eso es posible.

Y así me dirijo a ti. ¿Qué es exactamente ese final si se comprueba el bloque?

EDITAR: He seguido el razonamiento proporcionado en los comentarios de la respuesta seleccionada, que puede ser posible causar intencionalmente que argv [0] se convierta en NULL, o de lo contrario se convierta en NULL en base a una implementación de main de plataforma específica.

argc le proporcionará el número de argumentos de línea de comando pasados. No debería tener que revisar el contenido de argv también para ver si no hay suficientes argumentos.

 if (argc <= 1) { // The first arg will be the executable name // print usage } 

3.6.1 / 2:

Si argc es distinto de cero, dichos argumentos se proporcionarán en argv [0] aunque … y argv [0] será el puntero al carácter inicial de una NTMBS que representa el nombre utilizado para invocar el progtwig o “”. El valor de argc será no negativo. El valor de argv[argc] será 0.

Énfasis mío. argc solo se garantiza no negativo, no es cero.

Esto es en la entrada a la principal. También es posible que //do stuff modifique el valor de argv , o el contenido de la matriz a la que apunta. No es del todo extraño que el código de manejo de opciones desplace los valores fuera de argv a medida que los procesa. Por lo tanto, la prueba para *argv == null puede estar probando si quedan o no argumentos de línea de comando, después de que las opciones se hayan eliminado o se hayan omitido. Tendrías que mirar el rest del código.

Recordando qué tan portátil es C, es posible que no siempre se ejecute en una plataforma estándar como Windows o Unix. Tal vez sea un microcódigo dentro de su lavadora que se ejecuta en algún entorno barato y pirateado. Como tal, es una buena práctica asegurarse de que un puntero no sea nulo antes de anular la referencia, lo que podría haber llevado a la pregunta.

Aun así, tienes razón. * argv es el mismo que argv [0], y se supone que argv debe ser inicializado por el entorno, si se proporciona.

Sólo una especulación.

¿Y si tu profesor se refiere a esto?

 while(*++argv !=NULL) printf("%s\n",*argv);