¿Por qué deberíamos usar 0 en lugar de NULL siempre que sea posible en C++?
Desde Internet, únicamente para aprendizaje y comunicación.
En primer lugar, debes comprender que NULL es algo sin tipo y una macro. Desde el nacimiento de C ++, las macros han sido algo que el padre de C ++ despreciaba. Abogó por evitar las macros tanto como fuera posible. En sus preguntas frecuentes, también hay una explicación correspondiente sobre NULL y 0, que también habla de esto. Stroustrup: estilo y técnica de C++
En el estándar C++, podemos ver una palabra llamada constante de puntero nulo. De hecho, antes del estándar C++ 11, solo se reconocía 0 como constante de puntero nulo. Por lo tanto, en C ++, a menudo escuchamos el dicho de que al asignar un puntero nulo, se debe usar 0 en lugar de NULL. Después del lanzamiento de C++ 11, el término constante de puntero nullptr finalmente agregó otro miembro, que es nullptr. La diferencia esencial con NULL es que nullptr está escrito (colocado en el archivo de encabezado stddef) y el tipo es typdef decltype(nullptr) nullptr_t. Y precisamente porque está escrito, esto nos da la oportunidad al compilador de implementar nullptr. consideraciones más detalladas y, por supuesto, brinda a los usuarios más protección, por lo que si su compilador admite nullptr, ¡asegúrese de usar nullptr!
El trasfondo del surgimiento de nullptr es en realidad muy simple. En términos de la filosofía de C++, el padre de C++ siempre ha estado muy insatisfecho con la falta de una expresión formal del puntero nulo. Se trata de consejos pesados. Cargue esta pregunta.
nulo f(nulo*)
{
}
nulo f(int)
{
}
int main()
{
f(0); // ¿qué función se llamará?
}
Con la introducción de nullptr, este problema realmente se resolvió y se ajustará sin problemas a la versión void f(void*).
Bien, ¿realmente crees que nullptr es así? Dije antes que nullptr tiene un tipo, llamado nullptr_t, que trae muchas cosas a considerar en nuestra implementación del compilador. Desafortunadamente, tomemos algunas cosas raras. ejemplos!
unión U
{
long i;
nullptr_t t;
};
int main()
{
U u;
u.i = 3;
printf("%ld\n ",(long)u.t); // ¿Qué es? ¿0 o 3?
}
Entonces, ¿debería esto ajustarse a la semántica de union o nullptr? Esto no se menciona en la norma y hemos estado discutiendo sobre esto durante mucho tiempo. Por supuesto, la implementación de nuestro compilador aún mantiene la semántica de nullptr y el resultado es 0.
Ahora que nullptr tiene un tipo, ¿qué más puede hacer? Por supuesto, se pueden detectar excepciones.
int main()
{
intentar
{
tirar nullptr
}
catch(nullptr_t)
{
}
}
Intentas lanzar un NULL ¿intentar? Depende de qué tipo se debe usar para recolectar. Es precisamente porque no hay ningún tipo, por lo que se debe usar su tipo esencial, como long o algo así.
¿Podrías intentar tirar un 0? Entonces no es el llamado tipo de puntero nulo, significa usar int o algo así para recopilarlo.
Por lo tanto, tiene sentido recomendar nullptr. Consideramos muchos detalles cuando el compilador implementó nullptr. También hay muchas situaciones que quizás nunca uses, y todos las usamos para probar. es proteger el uso de los desarrolladores. Nuevamente, si su compilador admite nullptr, ¡use nullptr!
Una última cosa, 0 es algo muy mágico en C++. Por ejemplo, ¿por qué la función virtual pura se establece en =0? Me pregunto si algún estudiante ha considerado este problema. Si tiene un conocimiento profundo de la filosofía de C++, esta debería ser una pregunta muy simple. Al aprender un idioma, debes aprender su filosofía para poder conocer su belleza y potencia, especialmente C++.