static_castwidok kontra dynamic_castkontra reinterpret_castwewnętrzne na downcast / upcast
W tej odpowiedzi chcę porównać te trzy mechanizmy na konkretnym przykładzie upcast / downcast i przeanalizować, co dzieje się z podstawowymi wskaźnikami / pamięcią / zestawem, aby uzyskać konkretne zrozumienie ich porównania.
Wierzę, że da to dobrą intuicję na temat różnic między tymi obsadami:
static_cast: robi jedno przesunięcie adresu w czasie wykonywania (mały wpływ w czasie działania) i nie sprawdza bezpieczeństwa, czy downcast jest poprawny.
dyanamic_cast: robi to samo przesunięcie adresu jak w czasie wykonywania static_cast, ale także i kosztowną kontrolę bezpieczeństwa, czy downcast jest poprawny przy użyciu RTTI.
Ta kontrola bezpieczeństwa pozwala zapytać, czy wskaźnik klasy bazowej jest określonego typu w czasie wykonywania, sprawdzając, czy zwrot nullptrwskazuje nieprawidłowy downcast.
Dlatego jeśli twój kod nie jest w stanie tego sprawdzić nullptri podjąć prawidłowej akcji nie przerywania, powinieneś użyć static_castzamiast dynamicznego rzutowania.
Jeśli przerwanie jest jedyną czynnością, jaką może wykonać Twój kod, być może chcesz tylko włączyć dynamic_castkompilacje debugowania ( -NDEBUG) i użyć static_castinaczej, np. Tak jak tutaj , aby nie spowalniać szybkiego uruchamiania.
reinterpret_cast: nic nie robi w czasie wykonywania, nawet przesunięcie adresu. Wskaźnik musi wskazywać dokładnie odpowiedni typ, nawet klasa podstawowa nie działa. Zasadniczo nie chcesz tego, chyba że zaangażowane są strumienie surowych bajtów.
Rozważ następujący przykład kodu:
main.cpp
#include <iostream>
struct B1 {
B1(int int_in_b1) : int_in_b1(int_in_b1) {}
virtual ~B1() {}
void f0() {}
virtual int f1() { return 1; }
int int_in_b1;
};
struct B2 {
B2(int int_in_b2) : int_in_b2(int_in_b2) {}
virtual ~B2() {}
virtual int f2() { return 2; }
int int_in_b2;
};
struct D : public B1, public B2 {
D(int int_in_b1, int int_in_b2, int int_in_d)
: B1(int_in_b1), B2(int_in_b2), int_in_d(int_in_d) {}
void d() {}
int f2() { return 3; }
int int_in_d;
};
int main() {
B2 *b2s[2];
B2 b2{11};
D *dp;
D d{1, 2, 3};
// The memory layout must support the virtual method call use case.
b2s[0] = &b2;
// An upcast is an implicit static_cast<>().
b2s[1] = &d;
std::cout << "&d " << &d << std::endl;
std::cout << "b2s[0] " << b2s[0] << std::endl;
std::cout << "b2s[1] " << b2s[1] << std::endl;
std::cout << "b2s[0]->f2() " << b2s[0]->f2() << std::endl;
std::cout << "b2s[1]->f2() " << b2s[1]->f2() << std::endl;
// Now for some downcasts.
// Cannot be done implicitly
// error: invalid conversion from ‘B2*’ to ‘D*’ [-fpermissive]
// dp = (b2s[0]);
// Undefined behaviour to an unrelated memory address because this is a B2, not D.
dp = static_cast<D*>(b2s[0]);
std::cout << "static_cast<D*>(b2s[0]) " << dp << std::endl;
std::cout << "static_cast<D*>(b2s[0])->int_in_d " << dp->int_in_d << std::endl;
// OK
dp = static_cast<D*>(b2s[1]);
std::cout << "static_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "static_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
// Segfault because dp is nullptr.
dp = dynamic_cast<D*>(b2s[0]);
std::cout << "dynamic_cast<D*>(b2s[0]) " << dp << std::endl;
//std::cout << "dynamic_cast<D*>(b2s[0])->int_in_d " << dp->int_in_d << std::endl;
// OK
dp = dynamic_cast<D*>(b2s[1]);
std::cout << "dynamic_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "dynamic_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
// Undefined behaviour to an unrelated memory address because this
// did not calculate the offset to get from B2* to D*.
dp = reinterpret_cast<D*>(b2s[1]);
std::cout << "reinterpret_cast<D*>(b2s[1]) " << dp << std::endl;
std::cout << "reinterpret_cast<D*>(b2s[1])->int_in_d " << dp->int_in_d << std::endl;
}
Kompiluj, uruchamiaj i dezasembluj za pomocą:
g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
setarch `uname -m` -R ./main.out
gdb -batch -ex "disassemble/rs main" main.out
gdzie setarchjest używany do wyłączenia ASLR aby ułatwić porównanie przebiegów.
Możliwe wyjście:
&d 0x7fffffffc930
b2s[0] 0x7fffffffc920
b2s[1] 0x7fffffffc940
b2s[0]->f2() 2
b2s[1]->f2() 3
static_cast<D*>(b2s[0]) 0x7fffffffc910
static_cast<D*>(b2s[0])->int_in_d 1
static_cast<D*>(b2s[1]) 0x7fffffffc930
static_cast<D*>(b2s[1])->int_in_d 3
dynamic_cast<D*>(b2s[0]) 0
dynamic_cast<D*>(b2s[1]) 0x7fffffffc930
dynamic_cast<D*>(b2s[1])->int_in_d 3
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940
reinterpret_cast<D*>(b2s[1])->int_in_d 32767
Teraz, jak wspomniano na stronie : https://en.wikipedia.org/wiki/Virtual_method_table, aby skutecznie wspierać wirtualne wywołania metod, struktura danych pamięci Dmusi wyglądać mniej więcej tak:
B1:
+0: pointer to virtual method table of B1
+4: value of int_in_b1
B2:
+0: pointer to virtual method table of B2
+4: value of int_in_b2
D:
+0: pointer to virtual method table of D (for B1)
+4: value of int_in_b1
+8: pointer to virtual method table of D (for B2)
+12: value of int_in_b2
+16: value of int_in_d
Kluczowym faktem jest to, że struktura danych pamięci Dzawiera w sobie strukturę pamięci zgodną ze strukturą wewnętrzną B1i B2wewnętrzną.
Dlatego dochodzimy do krytycznego wniosku:
Upcast lub downcast musi jedynie przesunąć wartość wskaźnika o wartość znaną w czasie kompilacji
W ten sposób, gdy Dzostanie przekazany do tablicy typów bazowych, rzutowany typ faktycznie oblicza to przesunięcie i wskazuje coś, co wygląda dokładnie tak, jak prawidłowe B2w pamięci:
b2s[1] = &d;
poza tym, że ten ma Dzamiast tego vtable B2, dlatego wszystkie wirtualne połączenia działają transparentnie.
Teraz możemy wreszcie wrócić do odlewania czcionek i analizy naszego konkretnego przykładu.
Z wyjścia standardowego widzimy:
&d 0x7fffffffc930
b2s[1] 0x7fffffffc940
Dlatego domyślnie static_castwykonane tam poprawnie obliczyło przesunięcie od pełnej Dstruktury danych w 0x7fffffffc930 do B2podobnej, która jest w 0x7fffffffc940. Wnioskujemy również, że między 0x7fffffffc930 a 0x7fffffffc940 prawdopodobnie są to B1dane i vtable.
Następnie w sekcjach spuszczanych łatwo jest zrozumieć, dlaczego zawiodły nieprawidłowe i dlaczego:
static_cast<D*>(b2s[0]) 0x7fffffffc910: kompilator właśnie poszedł w górę 0x10 w bajtach czasu kompilacji, aby spróbować przejść od a B2do zawierającegoD
Ale ponieważ b2s[0]nie było D, wskazuje teraz na nieokreślony region pamięci.
Demontaż to:
49 dp = static_cast<D*>(b2s[0]);
0x0000000000000fc8 <+414>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x0000000000000fcc <+418>: 48 85 c0 test %rax,%rax
0x0000000000000fcf <+421>: 74 0a je 0xfdb <main()+433>
0x0000000000000fd1 <+423>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x0000000000000fd5 <+427>: 48 83 e8 10 sub $0x10,%rax
0x0000000000000fd9 <+431>: eb 05 jmp 0xfe0 <main()+438>
0x0000000000000fdb <+433>: b8 00 00 00 00 mov $0x0,%eax
0x0000000000000fe0 <+438>: 48 89 45 98 mov %rax,-0x68(%rbp)
więc widzimy, że GCC:
- sprawdź, czy wskaźnik ma wartość NULL, a jeśli tak, zwróć wartość NULL
- w przeciwnym razie odejmij od niego 0x10, aby osiągnąć to,
Dco nie istnieje
dynamic_cast<D*>(b2s[0]) 0: C ++ faktycznie stwierdził, że rzutowanie było nieprawidłowe i zwrócił nullptr!
Nie można tego zrobić w czasie kompilacji, a my potwierdzimy to z dezasemblacji:
59 dp = dynamic_cast<D*>(b2s[0]);
0x00000000000010ec <+706>: 48 8b 45 d0 mov -0x30(%rbp),%rax
0x00000000000010f0 <+710>: 48 85 c0 test %rax,%rax
0x00000000000010f3 <+713>: 74 1d je 0x1112 <main()+744>
0x00000000000010f5 <+715>: b9 10 00 00 00 mov $0x10,%ecx
0x00000000000010fa <+720>: 48 8d 15 f7 0b 20 00 lea 0x200bf7(%rip),%rdx # 0x201cf8 <_ZTI1D>
0x0000000000001101 <+727>: 48 8d 35 28 0c 20 00 lea 0x200c28(%rip),%rsi # 0x201d30 <_ZTI2B2>
0x0000000000001108 <+734>: 48 89 c7 mov %rax,%rdi
0x000000000000110b <+737>: e8 c0 fb ff ff callq 0xcd0 <__dynamic_cast@plt>
0x0000000000001110 <+742>: eb 05 jmp 0x1117 <main()+749>
0x0000000000001112 <+744>: b8 00 00 00 00 mov $0x0,%eax
0x0000000000001117 <+749>: 48 89 45 98 mov %rax,-0x68(%rbp)
Najpierw jest sprawdzanie NULL i zwraca NULL, jeśli einput ma wartość NULL.
W przeciwnym razie ustawia niektóre argumenty w RDX, RSI i RDI oraz wywołania __dynamic_cast.
Nie mam teraz cierpliwości, aby dalej to analizować, ale jak powiedzieli inni, jedynym sposobem na to jest __dynamic_castdostęp do niektórych dodatkowych struktur danych w pamięci RTTI, które reprezentują hierarchię klas.
Dlatego musi zaczynać od B2wpisu dla tej tabeli, a następnie przejść tę hierarchię klas, aż stwierdzi, że vtable dla Dtypecast z b2s[0].
Dlatego reinterpretacja obsady jest potencjalnie droga! Oto przykład, w którym łatka jednowarstwowa przekształcająca dynamic_casta static_castw złożony projekt skróciła czas działania o 33%! .
reinterpret_cast<D*>(b2s[1]) 0x7fffffffc940ten po prostu wierzy nam na ślepo: powiedzieliśmy, że jest Dadres b2s[1], a kompilator nie wykonuje obliczeń przesunięcia.
Ale to źle, ponieważ D faktycznie ma 0x7fffffffc930, a co 0x7fffffffc940 to struktura podobna do B2 wewnątrz D! Więc dostęp do śmieci.
Możemy to potwierdzić z przerażającego -O0zestawu, który po prostu przesuwa wartość:
70 dp = reinterpret_cast<D*>(b2s[1]);
0x00000000000011fa <+976>: 48 8b 45 d8 mov -0x28(%rbp),%rax
0x00000000000011fe <+980>: 48 89 45 98 mov %rax,-0x68(%rbp)
Powiązane pytania:
Testowane na Ubuntu 18.04 amd64, GCC 7.4.0.