Nullptr y verificar si un puntero apunta a un objeto válido

En un par de mis proyectos de código más antiguos cuando nunca había oído hablar de los punteros inteligentes, cada vez que necesitaba verificar si el puntero aún apuntaba a un objeto válido, siempre hacía algo como esto…

object * meh = new object;
if(meh) 
    meh->member;

O cuando necesitaba eliminar el objeto de forma segura, algo como esto

if(meh)
{
    delete meh;
    meh = 0;
}

Bueno, ahora he aprendido acerca de los problemas que pueden surgir al usar objetos y punteros en expresiones booleanas tanto con números literales, de la manera difícil:. Y ahora también he aprendido de la característica no tan nueva pero genial de C++, el nullptr palabra clave. Pero ahora tengo curiosidad.

Ya revisé y revisé la mayor parte de mi código para que, por ejemplo, al eliminar objetos ahora escribo

if(meh)
{
    delete meh;
    meh = nullptr;
}

Ahora me pregunto sobre el booleano. Cuando pase, simplemente diga un int en una declaración if como esta,

int meh;
if(meh)

Luego, comprueba implícitamente el cero sin necesidad de escribirlo.

if(meh == 0) // does the exact same check

Ahora, ¿C++ hará lo mismo con los punteros? Si pasa un char * como este a una declaración if?

char * meh;
if(meh)

Entonces, ¿lo comparará implícitamente con nullptr? Debido a cuánto tiempo he estado escribiendo estos ifs como este, es una segunda naturaleza en este punto verificar si los punteros son válidos antes de usarlos escribiendo if (objeto *) y luego llamando a sus miembros. Si esta no es la funcionalidad, ¿por qué no? ¿Demasiado difícil de implementar? Resolvería algunos problemas al eliminar otra pequeña forma en que podría estropear su código.

En C, cualquier cosa que no sea 0 es verdadera. Entonces, ciertamente puedes usar:

if (ptrToObject) 
    ptrToObject->doSomething();

para desreferenciar punteros de forma segura.

C++11 cambia un poco el juego, nullptr_t es un tipo del cual nullptr es una instancia; la representación de nullptr_t es específico de la implementación. Entonces un compilador puede definir nullptr_t como quiera. Solo necesita asegurarse de que puede imponer la restricción adecuada en el lanzamiento de un nullptr_t a diferentes tipos, de los cuales booleano está permitido, y asegúrese de que pueda distinguir entre un nullptr_t y 0

Asi que nullptr será adecuada e implícitamente echada a la booleano false siempre que el compilador siga la especificación del lenguaje C++11. Y el fragmento anterior todavía funciona.

Si elimina un objeto al que se hace referencia, nada cambia.

delete ptrToObject;
assert(ptrToObject);
ptrToObject = nullptr;
assert(!ptrToObject);    

Debido a cuánto tiempo he estado escribiendo estos ifs como este, es una segunda naturaleza en este punto verificar si los punteros son válidos antes de usarlos escribiendo if (objeto *) y luego llamando a sus miembros.

No. Mantenga un gráfico adecuado de objetos (preferiblemente utilizando punteros únicos/inteligentes). Como se señaló, no hay forma de determinar si un puntero que no es nullptr apunta a un objeto válido o no. Usted tiene la responsabilidad de mantener el ciclo de vida de todos modos… es por eso que los contenedores de puntero existen en primer lugar.

De hecho, debido a que el ciclo de vida de compartido y débil los punteros están bien definidos, tienen azúcar sintáctica que le permite usarlos de la manera que desee usar punteros desnudos, donde los punteros válidos tienen un valor y todos los demás son nullptr:

Compartido

#include <iostream>
#include <memory>

void report(std::shared_ptr<int> ptr) 
{
    if (ptr) {
        std::cout << "*ptr=" << *ptr << "\n";
    } else {
        std::cout << "ptr is not a valid pointer.\n";
    }
}

int main()
{
    std::shared_ptr<int> ptr;
    report(ptr);

    ptr = std::make_shared<int>(7);
    report(ptr);
}

Débil

#include <iostream>
#include <memory>

void observe(std::weak_ptr<int> weak) 
{
    if (auto observe = weak.lock()) {
        std::cout << "\tobserve() able to lock weak_ptr<>, value=" << *observe << "\n";
    } else {
        std::cout << "\tobserve() unable to lock weak_ptr<>\n";
    }
}

int main()
{
    std::weak_ptr<int> weak;
    std::cout << "weak_ptr<> not yet initialized\n";
    observe(weak);

    {
        auto shared = std::make_shared<int>(42);
        weak = shared;
        std::cout << "weak_ptr<> initialized with shared_ptr.\n";
        observe(weak);
    }

    std::cout << "shared_ptr<> has been destructed due to scope exit.\n";
    observe(weak);
}

Ahora, ¿C++ hará lo mismo con los punteros? Si pasa un char * como este a una declaración if?

Así que para responder a la pregunta: con desnudo punteros, no. Con envuelto punteros, sí.

_{Envuelva sus punteros, amigos.}

No es posible probar si un puntero apunta a un objeto válido o no. Si el puntero no es nulo pero no apunta a un objeto válido, el uso del puntero provoca un comportamiento indefinido. Para evitar este tipo de error, usted tiene la responsabilidad de tener cuidado con la vida útil de los objetos a los que se apunta; y las clases de puntero inteligente ayudan con esta tarea.

Si meh es un puntero en bruto, entonces no hay diferencia alguna entre if (meh) y if (meh != 0) y if (meh != nullptr). Todos proceden si el puntero no es nulo.

Hay una conversión implícita del literal. 0 a nullptr .