W języku C++ 11, czy dynamic_cast zwraca wartość nullptr lub 0?

Question

Chcę sprawdzić wynik dynamic_cast. W C++ 11 (lub C++ 0x, dla kompilatorów obsługujących nullptr), czy powinienem porównać z nullptr lub 0?

Czy to ma znaczenie, a jeśli tak, dlaczego?

Czy wynik zależy od kompilatora?

Answer 1

Zarówno stała nullptr (który jest typu nullptr_t) i stała 0 niejawnie przekonwertować na wartość pustą dowolnego typu wskaźnika. Tak więc porównanie z jednym z nich zadziała i jest technicznie w porządku. Nawiasem mówiąc, oznacza to, że dynamic_cast nie zwraca żadnego z nich, zwraca wartość pustą dla określonego typu wskaźnika.

Najlepiej jest uzyskać nawyk używania nullptr zamiast 0. Z tego, co wiem, jest to naprawdę konieczne dla właściwej rozdzielczości przeciążenia (np. Jedna przeciążenie pobiera int, a druga zajmuje char*). Aby zachować spójność, najlepiej będzie unikać unikania 0.

Co mam na myśli przez "wartość zerową typu wskaźnika"?

Rozważ zmienną char * ptr. Jego typ jest (nie zaskakuje) char *. Typ nullptr to specjalny typ nullptr_t. Kiedy więc napisać coś jak ptr = nullptr, niektóre rzeczy techniczne muszą zdarzyć

1. nullptr musi być niejawnie konwertowane do char *.
2. Wynik tej konwersji jest ustawiony jako nowa wartość ptr.

zerowa wartość char * jest wynikiem konwersji nullptr do char *. Koncepcyjnie nadal jest to nullptr, ale z innym typem (char *). Ta wartość pusta jest różna od wartości pustej int * lub string * lub dowolnego innego typu wskaźnika. Mamy tendencję do myślenia o tych zerowych wartościach jako nullptr (lub 0), ale każda z nich jest naprawdę odrębną wartością od innego typu. (Nawiasem mówiąc, ta sama konwersja dzieje się dla porównania przy użyciu ==).

Chociaż może to brzmieć jak szczegóły nitpicking, to bardzo ważne w rozdzielczości przeciążenia:

void foo(char * ptr) { ... } 
void foo(int i) { ... } 
void foo(nullptr_t ptr) { ... } 

int main() 
{ 
    foo(0); // Calls void foo(int), since 0 is an int 
    foo(nullptr); // Calls void foo(nullptr_t), since nullptr is a nullptr_t 
    foo(new char('c')); // Calls void foo(char *), since new char('c') is a char* 
} 

lub podczas przypisywania niepowiązanych wartości null:

char * c_ptr = nullptr; // Okay 
int * i_ptr1 = nullptr; // Okay 
int * i_ptr2 = c_ptr; // COMPILER ERROR HERE 

Answer 2

Ocenić wynik w kontekście logicznym:

Base * p = get(); 

if (Derived * q = dynamic_cast<Derived *>(p)) 
{ 
    q->derived_method(); 
} 
else 
{ 
    // *p isn't of type Derived 
} 

(. To działa w każdej wersji C++)