Posso trasmettere nullptr ad un altro tipo di puntatore?

Question

Posso fare questo?

static_cast<A*>(getSomePtr()); 

dove getSomePtr() tornerà nullptr. Va bene?

Answer 1

Da Wikipedia article:

... puntatore nullo costante: nullptr. È del tipo nullptr_t, che è implicitamente convertibile e paragonabile a qualsiasi tipo di puntatore o tipo puntatore-membro. Non è implicitamente trasformabile in o paragonabile a tipi interi, ad eccezione di bool.

nullptr è implicitamente convertibile in qualsiasi tipo di puntatore in modo conversione esplicita con static_cast è assolutamente valida.

Answer 2

Sì, puoi farlo. Sarà ancora nullo, quindi non è sicuro chiamare i suoi membri o dati, ma puoi porre domande sulla sua struttura in fase di compilazione.

Ad esempio, questo è un possible implementation of the offsetof(type, member) function in <cstddef>, in cui nullptr viene colato ad un tipo valido:

#define offsetof(type,member) ((std::size_t) &((static_cast<type*>(nullptr))->member)) 

Answer 3

Sospetto che tu sia confuso sulla differenza tra un puntatore nullo e nullptr, non sono la stessa cosa.

Questa funzione restituisce nullptr:

std::nullptr_t getNullPtr() { return nullptr; } 

Ma questa è una cosa abbastanza inutile ritornare, non v'è molto raramente una buona ragione per restituire un oggetto di quel tipo.

Questa funzione restituisce un puntatore nullo:

A* getAPtr() { return nullptr; } 

Il valore restituito viene inizializzato con nullptr ma in realtà è un puntatore nullo di tipo A*, non nullptr stessa.

Per la prima funzione, sì, è possibile eseguire il cast dello std::nullptr_t restituito a un altro tipo di puntatore (non è nemmeno necessario un cast per eseguire la conversione, si verificherà in modo implicito) ma probabilmente non è qualcosa che si vorrebbe mai fare .

Per la seconda funzione non è necessario eseguire il cast perché restituisce già il tipo corretto.

Answer 4

Solo un'aggiunta alle risposte date finora, ma generalizzando la tua domanda un po '(sul casting dei valori di ritorno, vedi le altre risposte): la trasmissione nullptr esplicitamente non è solo valida, ci sono alcune situazioni in cui persino è inevitabile! Ad esempio, se ci sono diverse funzioni sovraccaricate, ognuno di loro accettare un diverso tipo di puntatore ed è necessario (per qualsiasi ragione) chiamare uno di loro con nullptr ...

void f(int*) { /*...*/ } 
void f(double*) { /*...*/ } 
void g() 
{ 
    f(nullptr); // compilation error, ambiguous call! 
    f(static_cast<int*>(nullptr)); // now compiler knows... 
}