¿Qué significa hacer una “ verificación nula ” en C o C ++?

En C y C ++, los punteros son intrínsecamente inseguros, es decir, cuando se elimina la referencia a un puntero, es su propia responsabilidad asegurarse de que apunte a un lugar válido; esto es parte de lo que se trata la «administración manual de memoria» (a diferencia de los esquemas de administración automática de memoria implementados en lenguajes como Java , PHP o el tiempo de ejecución .NET, que no le permitirá crear referencias inválidas sin un esfuerzo considerable).

Una solución común que detecta muchos errores es establecer todos los punteros que no apuntan a nada como NULL (o, en C ++ correcto, 0) y verificando eso antes de acceder al puntero. Específicamente, es una práctica común inicializar todos los punteros a NULL (a menos que ya tenga algo a lo que apuntar cuando los declare), y establecerlos en NULL cuando delete o free() ellos (a menos que salgan del alcance inmediatamente después de eso). Ejemplo (en C, pero también en C ++ válido):

void fill_foo(int* foo) { *foo = 23; // this will crash and burn if foo is NULL } 

Una versión mejor:

void fill_foo(int* foo) { if (!foo) { // this is the NULL check printf("This is wrong\n"); return; } *foo = 23; } 

Sin la verificación nula, pasar un puntero NULL a esta función provocará un error de segmento, y no hay nada que pueda hacer: el sistema operativo simplemente matará su proceso y tal vez core-dump o mostrará un cuadro de diálogo de informe de bloqueo. Con la verificación nula en su lugar, puede realizar el manejo adecuado de errores y recuperarse correctamente: corrija el problema usted mismo, cancele la operación actual, escriba una entrada de registro, notifique al usuario, lo que sea apropiado.

Comentarios

• @MrLister, ¿qué quieres decir con que las comprobaciones nulas no ‘ funcionan en C ++? Solo tiene que inicializar el puntero en nulo cuando lo declare.
• Lo que quiero decir es que debe recordar configurar el puntero en NULL o ganó ‘ t trabajo. Y si recuerdas, en otras palabras, si sabes que el puntero es NULL, no ‘ tendrás la necesidad de llamar a fill_foo de todos modos. fill_foo comprueba si el puntero tiene un valor, no si el puntero tiene un valor válido . En C ++, no se garantiza que los punteros sean NULL o que tengan un valor válido.
• Un assert () sería una mejor solución aquí. No tiene sentido ‘ intentar » estar a salvo «. Si se pasó NULL, es ‘ obviamente incorrecto, así que ¿por qué no bloquearse explícitamente para que el programador esté completamente al tanto? (Y en producción, no ‘ t importa, porque ‘ has probado que nadie llamará a fill_foo () con NULL, ¿verdad? En serio, ‘ no es tan difícil.)
• No ‘ te olvides para mencionar que una versión aún mejor de esta función debería usar referencias en lugar de punteros, haciendo que la verificación NULL sea obsoleta.
• De esto no se trata la administración manual de memoria, y un programa administrado también explotará, ( o generar una excepción al menos, como lo haría un programa nativo en la mayoría de los idiomas,) si intenta eliminar la referencia a una referencia nula.

El valor del puntero nulo representa un «ningún lugar» bien definido; es un valor de puntero inválido que garantiza una comparación desigual con cualquier otro valor de puntero. Intentar eliminar la referencia a un puntero nulo da como resultado un comportamiento indefinido y, por lo general, dará lugar a un error de tiempo de ejecución, por lo que debe asegurarse de que un puntero no sea NULL antes de intentar eliminar la referencia. Varias funciones de biblioteca de C y C ++ devolverán un puntero nulo para indicar una condición de error. Por ejemplo, la función de biblioteca malloc devolverá un valor de puntero nulo si no puede asignar el número de bytes que se han solicitado, e intentar acceder a la memoria a través de ese puntero (generalmente) conducirá a un error de tiempo de ejecución:

int *p = malloc(sizeof *p * N); p[0] = ...; // this will (usually) blow up if malloc returned NULL 

Por lo tanto, debemos asegurarnos de que la llamada malloc se haya realizado correctamente comprobando el valor de p contra NULL:

int *p = malloc(sizeof *p * N); if (p != NULL) // or just if (p) p[0] = ...; 

Ahora, agárrate a tus calcetines un minuto, esto va a obtener un poco irregular.

Hay un puntero nulo valor y un puntero nulo constante , y los dos no son necesariamente iguales. El valor del puntero nulo es cualquier valor que utilice la arquitectura subyacente para representar «ninguna parte». Este valor puede ser 0x00000000, 0xFFFFFFFF, 0xDEADBEEF o algo completamente diferente. No asuma que el valor del puntero nulo es siempre 0.

La constante del puntero nulo, OTOH, es siempre una expresión integral con valor 0. En lo que respecta a su código fuente , 0 (o cualquier expresión integral que se evalúe como 0) representa un puntero nulo. Tanto C como C ++ definen la macro NULL como la constante de puntero nulo. Cuando se compila su código, el puntero nulo constante será reemplazado por el puntero nulo valor apropiado en el código de máquina generado.

Además, tenga en cuenta que NULL es solo uno de los muchos posibles valores de puntero inválidos ; si declara una variable de puntero automático sin inicializarla explícitamente, como

int *p; 

el valor almacenado inicialmente en la variable es indeterminado , y puede no corresponder a una dirección de memoria válida o accesible. Desafortunadamente, no hay forma (portátil) de saber si un valor de puntero no NULL es válido o no antes de intentar usarlo. Por lo tanto, si está tratando con punteros, generalmente es una buena idea inicializarlos explícitamente a NULL cuando los declare, y ponerlos en NULL cuando no estén apuntando activamente a nada.

Tenga en cuenta que esto es más un problema en C que en C ++; C ++ idiomático no debería usar tanto punteros.

Hay un par de métodos, todos esencialmente hacen lo mismo cosa.

 int *foo = NULL; //sometimes set to 0x00 or 0 or 0L instead of NULL 

verificación nula (verifique si el puntero es nulo), versión A

 if( foo == NULL) 

verificación nula, versión B

 if( !foo ) //since NULL is defined as 0, !foo will return a value from a null pointer 

verificación nula, versión C

 if( foo == 0 ) 

De las tres, prefiero usar la primera verificación, ya que le dice explícitamente a los futuros desarrolladores lo que estaba tratando de verificar Y deja en claro que esperaba que foo fuera un puntero.

No es así. La única razón para usar un puntero en C ++ es porque desea explícitamente la presencia de punteros nulos; de lo contrario, puede tomar una referencia, que es semánticamente más fácil de usar y garantiza que no sea nulo.

Comentarios

• @James: ‘ nuevo ‘ en modo kernel?
• @James: Una implementación de C ++ que representa las capacidades que una mayoría significativa de C ++ los codificadores disfrutan. Eso incluye todas las funciones del lenguaje C ++ 03 (excepto export) y todas las funciones de la biblioteca C ++ 03 y TR1 y una buena parte de C ++ 11.
• Yo sí desearía que la gente no ‘ dijera que » las referencias garantizan que no sean nulas. » No ‘ t. Es tan fácil generar una referencia nula como un puntero nulo, y se propagan de la misma manera.
• @Stargazer: La pregunta es 100% redundante cuando solo usa las herramientas de la manera en que los diseñadores de lenguaje y los buenos la práctica sugiere que debería hacerlo.
• @DeadMG, no ‘ no importa si es redundante. No ‘ no respondió la pregunta . Lo ‘ lo diré de nuevo: -1.

Si no marca el valor NULL, especialmente, si se trata de un puntero a una estructura, es posible que haya encontrado una vulnerabilidad de seguridad: desreferencia del puntero NULL. La desreferencia del puntero NULL puede conducir a otras vulnerabilidades de seguridad graves, como el desbordamiento del búfer condición de carrera … que puede permitir que el atacante tome el control de su computadora.

Muchos proveedores de software como Microsoft, Oracle, Adobe, Apple … lanzan un parche de software para corregir estas vulnerabilidades de seguridad. Creo que debería comprobar el valor NULO de cada puntero 🙂