¿Por qué no es necesario que std :: shared_ptr sepa el tipo completo si está construido a partir de un valor no nulo?

Tengo una función de fábrica en factory.h que devuelve un std :: shared_ptr a una clase base en foo.h. Factory.h usa la declaración de reenvío a la clase base en lugar de incluir foo.h. Como el siguiente código:

factory.h:

#include <memory>

// forward declaration
class foo;

std::shared_ptr<foo> create_foo_A(int A);
std::shared_ptr<foo> create_foo_B(int A, int B);
void work_with_foo(std::shared_ptr<foo> ptr);

En un código de cliente, si se inicializaba std :: shared_ptr to foo con nullptr, el compilador avisaría.

main.cpp:

#include "factory.h"
int main()
{
    int type = 1;

    std::shared_ptr<foo> ptr(nullptr);    // <--- compile warning
    if (type == 1)
        ptr = create_foo_A(5566);
    else
        ptr = create_foo_B(5566, 7788);
    work_with_foo(ptr);

    return 0;
}

El mensaje de advertencia es:

warning C4150 : deletion of pointer to incomplete type 'foo'; no destructor called

Es razonable, ya que std :: shared_ptr no conoce el tipo completo de foo. Esta advertencia puede eliminarse si main.cpp incluye foo.h.

Pero si std :: shared_ptr se inicializó con non-nullptr, la compilación no avisaría. main.cpp:

#include "factory.h"
int main()
{
    int type = 1;

    if (type == 1)
    {
        std::shared_ptr<foo> ptr = create_foo_A(5566);    // <--- OK
        work_with_foo(ptr);
    }
    else
    {
        std::shared_ptr<foo> ptr = create_foo_B(5566, 7788);    // <--- OK
        work_with_foo(ptr);
    }

    return 0;
}

En esta escena, ¿por qué std :: shared_ptr no necesita saber el tipo completo de clase foo? ¿Es muy diferente cuando std :: shared_ptr se construye con nullptr y no nulo?