Me gustan los nuevos tipos de punteros en C ++ 11, pero a veces todavía necesito un puntero en bruto. Sin embargo, algo que me pone cada vez más triste con respecto a los tipos "en bruto" en C ++ es su costumbre de inicializar como indefinido cuando no se les da un valor explícito. A medida que uso std :: shared_ptr <> y similares más a menudo, esta necesidad de inicializar los punteros en bruto a nulo se siente cada vez más frágil e innecesaria. Estoy hablando de:

class foo
{
    ...
    std::shared_ptr< bar > pb;   // Initially null in whatever constructor.
    std::unique_ptr< dar > pd;   // Likewise.
    std::weak_ptr< gar > pg;     // And again.
    lar* pr;                     // Uh-oh! Who knows what this is? Better remember to initialize...
};

foo::foo( int j )
: pr( nullptr )
{...}

foo::foo( const string& s )
: pr( nullptr )
{...}

... etc.: many tedious and error-prone constructor definitions follow.

Lo que me gustaría, por lo tanto, es un "puntero en bruto con inicialización nula". Algo como:

class foo
{
    ...
    std::shared_ptr< bar > pb;   // Initially null in whatever constructor.
    std::unique_ptr< dar > pd;   // Likewise.
    std::weak_ptr< gar > pg;     // And again.
    raw_ptr< lar > pr;           // Once more with feeling.
};

foo::foo( int j )
{...}                            // No explicit pointer initialization necessary.

foo::foo( const string& s )
{...}

...

Más precisamente, lo que quiero es un tipo simple y barato que actúe exactamente como un puntero en bruto en todos los aspectos, excepto que su constructor predeterminado lo inicializa a nullptr.

Mi pregunta: (1) ¿Existe tal cosa en la biblioteca estándar? (2) Si no, ¿cuál sería la forma más elegante / más pequeña de lograr una implementación de este tipo?

PD No estoy interesado en Boost ni en ninguna otra biblioteca, a menos que sea una biblioteca de solo encabezado en un solo archivo. La pequeñez y la sencillez son esenciales.