Quale di questi creerà un puntatore nullo?

Question

Lo standard dice che il dereferenziamento del puntatore nullo porta a un comportamento non definito. Ma cos'è "il puntatore nullo"? Nel codice seguente, quello che noi chiamiamo "il puntatore nullo":

struct X 
{ 
    static X* get() { return reinterpret_cast<X*>(1); } 
    void f() { } 
}; 

int main() 
{ 
    X* x = 0; 
    (*x).f(); // the null pointer? (1) 

    x = X::get(); 
    (*x).f(); // the null pointer? (2) 

    x = reinterpret_cast<X*>(X::get() - X::get()); 
    (*x).f(); // the null pointer? (3) 

    (*(X*)0).f(); // I think that this the only null pointer here (4) 
} 

Il mio pensiero è che dereferenziazione del puntatore nullo avviene solo in quest'ultimo caso. Ho ragione? C'è differenza tra i point null di compilazione e il runtime secondo lo standard C++?

Answer 1

Solo il primo e l'ultimo sono puntatori nulli. Gli altri sono i risultati di reinterpret_cast e quindi operano sui valori di puntatore definiti dall'implementazione. Il fatto che il comportamento non sia definito per loro dipende dalla presenza o meno di un oggetto nell'indirizzo a cui sei stato assegnato.

Answer 2

Un'espressione costante intera che restituisce 0 è valida come puntatore nullo, quindi anche il primo caso dereferenzia un puntatore nullo.

Un puntatore che è impostato su 0 tramite un calcolo aritmetico non è necessariamente un puntatore nullo. Nella maggior parte delle implementazioni si comporta allo stesso modo di un puntatore nullo, ma questo non è garantito dallo standard.

Answer 3

X* x = 0; 
(*x).f(); // the null pointer? (1) 

penso che questo si qualifica come dereferenziare, anche se f() usa mai effettivamente il puntatore this, e non ci sono metodi virtuali in X. Il mio riflesso è stato dire che questo è un incidente, ma ora che ci penso, non ne sono così sicuro.

x = X::get(); 
(*x).f(); // the null pointer? (2) 

Probabilmente un puntatore non valido. non sono sicuro se si bloccherà (vedi sopra per il ragionamento).

x = reinterpret_cast<X*>(X::get() - X::get()); 
(*x).f(); // the null pointer? (3) 

Compilare l'espressione X::get() - X::get()? Non pensavo che fosse legale sottrarre un puntatore da un altro puntatore del genere.

EDIT: D'oh! Certo che è legale. Cosa stavo pensando? Chiaramente, sono un marrone.

Answer 4

C++ standard (2003) 4.10

4.10 Pointer conversioni

1 Un puntatore costante nullo è un integrante costante espressione (5.19) rvalue di tipo intero che restituisce a zero. Una costante puntatore nullo può essere convertita in in un tipo di puntatore; il risultato è il valore del puntatore nullo di di quel tipo ed è distinguibile da ogni altro valore del puntatore all'oggetto o puntatore al tipo di funzione. Due valori di puntatore nulli dello stesso tipo devono essere uguali a . La conversione di un puntatore nullo costante su un puntatore al tipo con certificazione cv è una singola conversione e non la sequenza di una conversione puntatore seguita da una conversione di qualificazione (4.4).

5.2.10 reinterpretare getto

Nota 64) Conversione di un integrale costante espressione (5.19) con valore zero cede sempre un puntatore nullo (4.10), ma convertendo altre espressioni che capita di avere valore zero necessità non fornire un puntatore nullo.

1) X* x = 0; (*x).f(); Sì. 0 è un'espressione costante integrata e viene convertita nella costante del puntatore nullo. Quindi la costante del puntatore nullo può essere convertita nel valore del puntatore nullo.

2) x = X::get(); no, vedi nota 64 a 5.2.10

3) x = reinterpret_cast<X*>(X::get() - X::get()); no, vedi nota 64 a 5.2.10

4) ((X) 0) .f() ; Sì. 0 (espressione costante integrata) -> costante del puntatore nullo -> valore del puntatore nullo.